firebase-tools 15.9.1 → 15.10.0

package/lib/appdistribution/distribution.js

@@ -39,7 +39,7 @@ async function upload(requests, appName, distribution) {
         utils.logSuccess(`View this release in the Firebase console: ${release.firebaseConsoleUri}`);
         utils.logSuccess(`Share this release with testers who have access: ${release.testingUri}`);
         utils.logSuccess(`Download the release binary (link expires in 1 hour): ${release.binaryDownloadUri}`);
-        return uploadResponse.release.name;
+        return uploadResponse.release;
     }
     catch (err) {
         if ((0, error_1.getErrStatus)(err) === 404) {

package/lib/appdistribution/options-parser-util.js

@@ -50,7 +50,14 @@ function getAppName(options) {
     }
     return toAppName(options.app);
 }
+const APP_ID_FORMAT = /^\d+:\d+:(android|ios|web):[a-fA-F0-9]+$/;
+function validateAppId(appId) {
+    if (!APP_ID_FORMAT.test(appId)) {
+        throw new error_1.FirebaseError(`Invalid Firebase app ID: ${appId}`);
+    }
+}
 function toAppName(appId) {
+    validateAppId(appId);
     return `projects/${appId.split(":")[1]}/apps/${appId}`;
 }
 function parseTestDevices(value, file = "") {

package/lib/apphosting/config.js

@@ -4,6 +4,7 @@ exports.APPHOSTING_YAML_FILE_REGEX = exports.APPHOSTING_LOCAL_YAML_FILE = export
 exports.discoverBackendRoot = discoverBackendRoot;
 exports.listAppHostingFilesInPath = listAppHostingFilesInPath;
 exports.load = load;
+exports.getAppHostingConfiguration = getAppHostingConfiguration;
 exports.store = store;
 exports.findEnv = findEnv;
 exports.upsertEnv = upsertEnv;
@@ -22,6 +23,7 @@ const yaml_1 = require("./yaml");
 const logger_1 = require("../logger");
 const csm = require("../gcp/secretManager");
 const error_1 = require("../error");
+const path_2 = require("path");
 exports.APPHOSTING_BASE_YAML_FILE = "apphosting.yaml";
 exports.APPHOSTING_EMULATORS_YAML_FILE = "apphosting.emulator.yaml";
 exports.APPHOSTING_LOCAL_YAML_FILE = "apphosting.local.yaml";
@@ -64,6 +66,28 @@ function load(yamlPath) {
     }
     return yaml.parseDocument(raw);
 }
+const dynamicDispatch = exports;
+async function getAppHostingConfiguration(backendDir) {
+    const appHostingConfigPaths = dynamicDispatch.listAppHostingFilesInPath(backendDir);
+    const fileNameToPathMap = Object.fromEntries(appHostingConfigPaths.map((path) => [(0, path_2.basename)(path), path]));
+    const output = yaml_1.AppHostingYamlConfig.empty();
+    const baseFilePath = fileNameToPathMap[exports.APPHOSTING_BASE_YAML_FILE];
+    const emulatorsFilePath = fileNameToPathMap[exports.APPHOSTING_EMULATORS_YAML_FILE];
+    const localFilePath = fileNameToPathMap[exports.APPHOSTING_LOCAL_YAML_FILE];
+    if (baseFilePath) {
+        const baseFile = await yaml_1.AppHostingYamlConfig.loadFromFile(baseFilePath);
+        output.merge(baseFile, false);
+    }
+    if (emulatorsFilePath) {
+        const emulatorsConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(emulatorsFilePath);
+        output.merge(emulatorsConfig, false);
+    }
+    if (localFilePath) {
+        const localYamlConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(localFilePath);
+        output.merge(localYamlConfig, true);
+    }
+    return output;
+}
 function store(yamlPath, document) {
     (0, fs_1.writeFileSync)(yamlPath, document.toString());
 }
@@ -94,7 +118,6 @@ function upsertEnv(document, env) {
     }
     envs.add(envYaml);
 }
-const dynamicDispatch = exports;
 async function maybeAddSecretToYaml(secretName, fileName = exports.APPHOSTING_BASE_YAML_FILE) {
     const backendRoot = dynamicDispatch.discoverBackendRoot(process.cwd());
     let path;

package/lib/commands/appdistribution-distribute.js

@@ -97,7 +97,7 @@ async function distribute(appName, distribution, testCases, testDevices, release
             }
         }
     }
-    const releaseName = await (0, distribution_1.upload)(requests, appName, distribution);
+    const release = await (0, distribution_1.upload)(requests, appName, distribution);
     if (aabInfo && !aabInfo.testCertificate) {
         aabInfo = await requests.getAabInfo(appName);
         if (aabInfo.testCertificate) {
@@ -110,17 +110,17 @@ async function distribute(appName, distribution, testCases, testDevices, release
                 `SHA-256 certificate fingerprint: ${aabInfo.testCertificate.hashSha256}`);
         }
     }
-    await requests.updateReleaseNotes(releaseName, releaseNotes);
-    await requests.distribute(releaseName, testers, groups);
+    await requests.updateReleaseNotes(release.name, releaseNotes);
+    await requests.distribute(release.name, testers, groups);
     if (testDevices.length) {
         utils.logBullet("starting automated test (note: this feature is in beta)");
         const releaseTestPromises = [];
         if (!testCases.length) {
-            releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, undefined, loginCredential));
+            releaseTestPromises.push(requests.createReleaseTest(release.name, testDevices, undefined, loginCredential));
         }
         else {
             for (const testCaseId of testCases) {
-                releaseTestPromises.push(requests.createReleaseTest(releaseName, testDevices, undefined, loginCredential, `${appName}/testCases/${testCaseId}`));
+                releaseTestPromises.push(requests.createReleaseTest(release.name, testDevices, undefined, loginCredential, `${appName}/testCases/${testCaseId}`));
             }
         }
         const releaseTests = await Promise.all(releaseTestPromises);

package/lib/commands/apptesting.js

@@ -8,7 +8,6 @@ const clc = require("colorette");
 const parseTestFiles_1 = require("../apptesting/parseTestFiles");
 const ora = require("ora");
 const error_1 = require("../error");
-const marked_1 = require("marked");
 const client_1 = require("../appdistribution/client");
 const distribution_1 = require("../appdistribution/distribution");
 const options_parser_util_1 = require("../appdistribution/options-parser-util");
@@ -38,13 +37,13 @@ exports.command = new command_1.Command("apptesting:execute <release-binary-file
         throw new error_1.FirebaseError("No tests found");
     }
     const invokeSpinner = ora("Requesting test execution");
-    let testInvocations;
-    let releaseId;
+    let releaseTests;
+    let release;
     try {
         const client = new client_1.AppDistributionClient();
-        releaseId = await (0, distribution_1.upload)(client, appName, new distribution_1.Distribution(target));
+        release = await (0, distribution_1.upload)(client, appName, new distribution_1.Distribution(target));
         invokeSpinner.start();
-        testInvocations = await invokeTests(client, releaseId, tests, !testDevices.length ? defaultDevices : testDevices);
+        releaseTests = await invokeTests(client, release.name, tests, !testDevices.length ? defaultDevices : testDevices);
         invokeSpinner.text = "Test execution requested";
         invokeSpinner.succeed();
     }
@@ -52,22 +51,22 @@ exports.command = new command_1.Command("apptesting:execute <release-binary-file
         invokeSpinner.fail("Failed to request test execution");
         throw ex;
     }
-    logger_1.logger.info(clc.bold(`\n${clc.white("===")} Running ${pluralizeTests(testInvocations.length)}`));
-    logger_1.logger.info(await (0, marked_1.marked)(`View progress and results in the Firebase Console`));
+    logger_1.logger.info(clc.bold(`\n${clc.white("===")} Running ${pluralizeTests(releaseTests.length)}`));
+    logger_1.logger.info(`View progress and results in the Firebase Console:\n${release.firebaseConsoleUri}`);
 });
 function pluralizeTests(numTests) {
     return `${numTests} test${numTests === 1 ? "" : "s"}`;
 }
 async function invokeTests(client, releaseName, testDefs, devices) {
     try {
-        const testInvocations = [];
+        const releaseTests = [];
         for (const testDef of testDefs) {
             const aiInstructions = {
                 steps: testDef.testCase.steps,
             };
-            testInvocations.push(await client.createReleaseTest(releaseName, devices, aiInstructions, undefined, undefined, testDef.testCase.displayName));
+            releaseTests.push(await client.createReleaseTest(releaseName, devices, aiInstructions, undefined, undefined, testDef.testCase.displayName));
         }
-        return testInvocations;
+        return releaseTests;
     }
     catch (err) {
         throw new error_1.FirebaseError("Test invocation failed", { original: (0, error_1.getError)(err) });

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

@@ -8,7 +8,6 @@ const requireAuth_1 = require("../requireAuth");
 const requirePermissions_1 = require("../requirePermissions");
 const ensureApis_1 = require("../dataconnect/ensureApis");
 const permissionsSetup_1 = require("../gcp/cloudsql/permissionsSetup");
-const permissions_1 = require("../gcp/cloudsql/permissions");
 const schemaMigration_1 = require("../dataconnect/schemaMigration");
 const connect_1 = require("../gcp/cloudsql/connect");
 const load_1 = require("../dataconnect/load");
@@ -33,9 +32,9 @@ exports.command = new command_1.Command("dataconnect:sql:setup")
     if (!instanceId) {
         throw new error_1.FirebaseError("dataconnect.yaml is missing field schema.datasource.postgresql.cloudsql.instanceId");
     }
-    const { serviceName, instanceName, databaseId } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
-    await (0, schemaMigration_1.ensureServiceIsConnectedToCloudSql)(serviceName, instanceName, databaseId, true);
+    const { serviceName, instanceName, databaseId, schemaName } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
+    await (0, schemaMigration_1.ensureServiceIsConnectedToCloudSql)(serviceName, instanceName, databaseId, true, schemaName);
     await (0, connect_1.setupIAMUsers)(instanceId, options);
-    const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
+    const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, schemaName, options);
     await (0, permissionsSetup_1.setupSQLPermissions)(instanceId, databaseId, schemaInfo, options);
 });

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

@@ -83,7 +83,7 @@ exports.command = new command_1.Command("dataconnect:sql:shell")
     const projectId = (0, projectUtils_1.needProjectId)(options);
     await (0, ensureApis_1.ensureApis)(projectId);
     const serviceInfo = await (0, load_1.pickOneService)(projectId, options.config, options.service, options.location);
-    const { instanceId, databaseId } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
+    const { instanceId, databaseId, schemaName } = (0, schemaMigration_1.getIdentifiers)((0, types_1.mainSchema)(serviceInfo.schemas));
     const { user: username } = await (0, connect_1.getIAMUser)(options);
     const instance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
     const connectionName = instance.connectionName;
@@ -104,6 +104,7 @@ exports.command = new command_1.Command("dataconnect:sql:shell")
         database: databaseId,
     });
     const conn = await pool.connect();
+    await conn.query(`SET search_path TO "${schemaName}"`);
     logger_1.logger.info(`Logged in as ${username}`);
     logger_1.logger.info(clc.cyan("Welcome to Data Connect Cloud SQL Shell"));
     logger_1.logger.info(clc.gray("Type your your SQL query or '.exit' to quit, queries should end with ';' or add empty line to execute."));

package/lib/commands/index.js

@@ -247,18 +247,16 @@ function load(client) {
     client.dataconnect.compile = loadCommand("dataconnect-compile");
     client.dataconnect.sdk = {};
     client.dataconnect.sdk.generate = loadCommand("dataconnect-sdk-generate");
-    if (experiments.isEnabled("studioexport")) {
-        client.studio = {};
-        client.studio.export = loadCommand("studio-export");
-    }
+    client.studio = {};
+    client.studio.export = loadCommand("studio-export");
     client.target = loadCommand("target");
     client.target.apply = loadCommand("target-apply");
     client.target.clear = loadCommand("target-clear");
     client.target.remove = loadCommand("target-remove");
     client.use = loadCommand("use");
+    client.apptesting = {};
+    client.apptesting.execute = loadCommand("apptesting");
     if (experiments.isEnabled("apptesting")) {
-        client.apptesting = {};
-        client.apptesting.execute = loadCommand("apptesting");
         client.apptesting.wata = loadCommand("apptesting-wata");
     }
     const t1 = process.hrtime.bigint();

package/lib/commands/studio-export.js

@@ -5,17 +5,35 @@ const command_1 = require("../command");
 const logger_1 = require("../logger");
 const migrate_1 = require("../firebase_studio/migrate");
 const path = require("path");
-const experiments = require("../experiments");
 const error_1 = require("../error");
+const unzip_1 = require("../unzip");
+const fs = require("fs");
 exports.command = new command_1.Command("studio:export <path>")
-    .description("Bootstrap Firebase Studio apps for migration to Antigravity. Run on the unzipped folder from the Firebase Studio download.")
-    .option("--no-start-agy", "skip starting the Antigravity IDE after migration")
+    .description("Bootstrap Firebase Studio apps for migration to Antigravity. Run on the unzipped folder from the Firebase Studio download, or directly on the downloaded zip file.")
+    .option("--no-start-antigravity", "skip starting the Antigravity IDE after migration")
     .action(async (exportPath, options) => {
-    experiments.assertEnabled("studioexport", "export Studio apps");
     if (!exportPath) {
         throw new error_1.FirebaseError("Must specify a path for migration.", { exit: 1 });
     }
-    const rootPath = path.resolve(exportPath);
-    logger_1.logger.info(`Exporting Studio apps from ${rootPath} to Antigravity...`);
+    let rootPath = path.resolve(exportPath);
+    if (fs.existsSync(rootPath) && fs.statSync(rootPath).isFile() && rootPath.endsWith(".zip")) {
+        logger_1.logger.info(`⏳ Unzipping ${rootPath}...`);
+        const parsedPath = path.parse(rootPath);
+        let extractDirName = parsedPath.name;
+        if (!extractDirName || extractDirName === ".") {
+            extractDirName = "studio-export";
+        }
+        const extractPath = path.join(parsedPath.dir, extractDirName);
+        await (0, unzip_1.unzip)(rootPath, extractPath);
+        const extractedItems = fs.readdirSync(extractPath);
+        if (extractedItems.length === 1 &&
+            fs.statSync(path.join(extractPath, extractedItems[0])).isDirectory()) {
+            rootPath = path.join(extractPath, extractedItems[0]);
+        }
+        else {
+            rootPath = extractPath;
+        }
+    }
+    logger_1.logger.info(`⏳ Exporting Studio app from ${rootPath} to Antigravity...`);
     await (0, migrate_1.migrate)(rootPath, options);
 });

package/lib/dataconnect/load.js

@@ -6,6 +6,7 @@ exports.loadAll = loadAll;
 exports.load = load;
 exports.readFirebaseJson = readFirebaseJson;
 exports.readDataConnectYaml = readDataConnectYaml;
+exports.inferClientCache = inferClientCache;
 exports.readConnectorYaml = readConnectorYaml;
 exports.readGQLFiles = readGQLFiles;
 exports.squashGraphQL = squashGraphQL;
@@ -28,7 +29,7 @@ async function pickOneService(projectId, config, service, location) {
 async function pickServices(projectId, config, serviceId, location) {
     const serviceInfos = await loadAll(projectId, config);
     if (serviceInfos.length === 0) {
-        throw new error_1.FirebaseError("No Data Connect services found in firebase.json." +
+        throw new error_1.FirebaseError("No Data Connect services found in firebase.json. " +
             `\nYou can run ${clc.bold("firebase init dataconnect")} to add a Data Connect service.`);
     }
     const matchingServices = serviceInfos.filter((i) => (!serviceId || i.dataConnectYaml.serviceId === serviceId) &&
@@ -63,6 +64,7 @@ async function load(projectId, config, sourceDirectory) {
         const connectorDir = path.join(resolvedDir, dir);
         const connectorYaml = await readConnectorYaml(connectorDir);
         const connectorGqls = await readGQLFiles(connectorDir);
+        const clientCache = inferClientCache(connectorYaml);
         return {
             directory: connectorDir,
             connectorYaml,
@@ -71,6 +73,7 @@ async function load(projectId, config, sourceDirectory) {
                 source: {
                     files: connectorGqls,
                 },
+                client_cache: clientCache,
             },
         };
     }));
@@ -122,6 +125,26 @@ function validateDataConnectYaml(unvalidated) {
     }
     return unvalidated;
 }
+function inferClientCache(connectorYaml) {
+    const platforms = [
+        connectorYaml.generate?.javascriptSdk,
+        connectorYaml.generate?.swiftSdk,
+        connectorYaml.generate?.kotlinSdk,
+        connectorYaml.generate?.dartSdk,
+    ];
+    for (const sdk of platforms) {
+        if (sdk) {
+            const sdkList = Array.isArray(sdk) ? sdk : [sdk];
+            if (sdkList.some((s) => s.clientCache)) {
+                return {
+                    strict_validation_enabled: true,
+                    entity_id_included: true,
+                };
+            }
+        }
+    }
+    return undefined;
+}
 async function readConnectorYaml(sourceDirectory) {
     const file = await (0, utils_1.readFileFromDirectory)(sourceDirectory, "connector.yaml");
     const connectorYaml = await (0, utils_1.wrappedSafeLoad)(file.source);

package/lib/dataconnect/schemaMigration.js

@@ -25,10 +25,10 @@ const errors = require("./errors");
 const provisionCloudSql_1 = require("./provisionCloudSql");
 const requireAuth_1 = require("../requireAuth");
 const cloudbilling_1 = require("../gcp/cloudbilling");
-async function setupSchemaIfNecessary(instanceId, databaseId, options) {
+async function setupSchemaIfNecessary(instanceId, databaseId, schemaName, options) {
     try {
         await (0, connect_1.setupIAMUsers)(instanceId, options);
-        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
+        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, schemaName, options);
         switch (schemaInfo.setupStatus) {
             case permissionsSetup_1.SchemaSetupStatus.BrownField:
             case permissionsSetup_1.SchemaSetupStatus.GreenField:
@@ -50,8 +50,8 @@ async function diffSchema(options, schema, schemaValidation) {
     let validationMode = schemaValidation ?? "STRICT";
     setSchemaValidationMode(schema, validationMode);
     displayStartSchemaDiff(validationMode);
-    const { serviceName, instanceName, databaseId, instanceId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
+    const { serviceName, instanceName, databaseId, instanceId, schemaName } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false, schemaName);
     let incompatible = undefined;
     try {
         await (0, client_1.upsertSchema)(schema, true);
@@ -114,8 +114,8 @@ async function migrateSchema(args) {
     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);
+    const { serviceName, instanceId, instanceName, databaseId, schemaName } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, true, schemaName);
     const existingInstance = await cloudSqlAdminClient.getInstance(projectId, instanceId);
     if (existingInstance.state === "PENDING_CREATE") {
         if (stats) {
@@ -134,7 +134,7 @@ async function migrateSchema(args) {
         (0, utils_1.logLabeledWarning)("dataconnect", `Skip SQL schema migration because Cloud SQL is still being created`);
         return [];
     }
-    await setupSchemaIfNecessary(instanceId, databaseId, options);
+    await setupSchemaIfNecessary(instanceId, databaseId, schemaName, options);
     let diffs = [];
     try {
         await (0, client_1.upsertSchema)(schema, validateOnly);
@@ -168,6 +168,7 @@ async function migrateSchema(args) {
                 options,
                 databaseId,
                 instanceId,
+                schemaName,
                 incompatibleSchemaError: incompatible,
                 choice: migrationMode,
             });
@@ -202,6 +203,7 @@ async function migrateSchema(args) {
                     options,
                     databaseId,
                     instanceId,
+                    schemaName,
                     incompatibleSchemaError: incompatible,
                     choice: migrationMode,
                 });
@@ -242,13 +244,13 @@ async function upsertSecondarySchema(args) {
 async function grantRoleToUserInSchema(options, schema) {
     const role = options.role;
     const email = options.email;
-    const { serviceName, instanceId, instanceName, databaseId } = getIdentifiers(schema);
-    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false);
-    const schemaSetupStatus = await setupSchemaIfNecessary(instanceId, databaseId, options);
+    const { serviceName, instanceId, instanceName, databaseId, schemaName } = getIdentifiers(schema);
+    await ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, false, schemaName);
+    const schemaSetupStatus = await setupSchemaIfNecessary(instanceId, databaseId, schemaName, options);
     if (schemaSetupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField && role === "owner") {
         throw new error_1.FirebaseError(`Owner rule isn't available in ${schemaSetupStatus} databases. If you would like Data Connect to manage and own your database schema, run 'firebase dataconnect:sql:setup'`);
     }
-    await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, role, email);
+    await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, role, email, schemaName);
 }
 function diffsEqual(x, y) {
     if (x.length !== y.length) {
@@ -280,11 +282,13 @@ function getIdentifiers(schema) {
         throw new error_1.FirebaseError("Data Connect schema must have a postgres datasource with a CloudSQL instance.");
     }
     const instanceId = instanceName.split("/").pop();
+    const schemaName = postgresDatasource?.postgresql?.schema || permissions_1.DEFAULT_SCHEMA;
     const serviceName = serviceNameFromSchema(schema);
     return {
         databaseId,
         instanceId,
         instanceName,
+        schemaName,
         serviceName,
     };
 }
@@ -299,7 +303,7 @@ function suggestedCommand(serviceName, invalidConnectorNames) {
     return `firebase deploy --only ${onlys}`;
 }
 async function handleIncompatibleSchemaError(args) {
-    const { incompatibleSchemaError, options, instanceId, databaseId, choice } = args;
+    const { incompatibleSchemaError, options, instanceId, databaseId, schemaName, choice } = args;
     const commandsToExecute = incompatibleSchemaError.diffs.filter((d) => {
         switch (choice) {
             case "all":
@@ -319,26 +323,29 @@ async function handleIncompatibleSchemaError(args) {
         Please ask a user with 'roles/cloudsql.admin' to apply the following commands.\n
         ${diffsToString(commandsToExecuteBySuperUser)}`);
         }
-        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, permissions_1.DEFAULT_SCHEMA, options);
+        const schemaInfo = await (0, permissionsSetup_1.getSchemaMetadata)(instanceId, databaseId, schemaName, options);
         if (schemaInfo.setupStatus !== permissionsSetup_1.SchemaSetupStatus.GreenField) {
             throw new error_1.FirebaseError(`Brownfield database are protected from SQL changes by Data Connect.\n` +
                 `You can use the SQL diff generated by 'firebase dataconnect:sql:diff' to assist you in applying the required changes to your CloudSQL database. Connector deployment will succeed when there is no required diff changes.\n` +
                 `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))) {
+        if (!(await (0, permissionsSetup_1.checkSQLRoleIsGranted)(options, instanceId, databaseId, (0, permissions_1.firebaseowner)(databaseId, schemaName), (await (0, connect_1.getIAMUser)(options)).user))) {
             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);
+            await (0, permissionsSetup_1.grantRoleTo)(options, instanceId, databaseId, "owner", account, schemaName);
         }
         if (commandsToExecuteBySuperUser.length) {
             (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.map((d) => d.sql)], false);
+            await (0, connect_1.executeSqlCmdsAsIamUser)(options, instanceId, databaseId, [
+                `SET ROLE "${(0, permissions_1.firebaseowner)(databaseId, schemaName)}"`,
+                ...commandsToExecuteByOwner.map((d) => d.sql),
+            ], false);
             return incompatibleSchemaError.diffs;
         }
     }
@@ -421,7 +428,7 @@ function displayInvalidConnectors(invalidConnectors) {
     (0, utils_1.logLabeledWarning)("dataconnect", `The schema you are deploying is incompatible with the following existing connectors: ${clc.bold(connectorIds)}.`);
     (0, utils_1.logLabeledWarning)("dataconnect", `This is a ${clc.red("breaking")} change and may break existing apps.`);
 }
-async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, linkIfNotConnected) {
+async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, databaseId, linkIfNotConnected, schemaName) {
     let currentSchema = await (0, client_1.getSchema)(serviceName);
     let postgresql = currentSchema?.datasources?.find((d) => d.postgresql)?.postgresql;
     if (currentSchema?.reconciling &&
@@ -478,6 +485,7 @@ async function ensureServiceIsConnectedToCloudSql(serviceName, instanceName, dat
     try {
         postgresql.schemaValidation = "STRICT";
         postgresql.database = databaseId;
+        postgresql.schema = schemaName;
         postgresql.cloudSql = { instance: instanceName };
         await (0, client_1.upsertSchema)(currentSchema, false);
     }

package/lib/dataconnect/types.js

@@ -16,6 +16,7 @@ function toDatasource(projectId, locationId, ds) {
         return {
             postgresql: {
                 database: ds.postgresql.database,
+                schema: ds.postgresql.schema,
                 cloudSql: {
                     instance: `projects/${projectId}/locations/${locationId}/instances/${ds.postgresql.cloudSql.instanceId}`,
                 },

package/lib/deploy/functions/build.js

@@ -226,18 +226,33 @@ function toBackend(build, paramValues) {
             r.resolveInts(bkEndpoint, bdEndpoint, "timeoutSeconds", "maxInstances", "minInstances", "concurrency");
             proto.convertIfPresent(bkEndpoint, bdEndpoint, "cpu", (0, functional_1.nullsafeVisitor)((cpu) => (cpu === "gcf_gen1" ? cpu : r.resolveInt(cpu))));
             if (bdEndpoint.vpc) {
-                bdEndpoint.vpc.connector = params.resolveString(bdEndpoint.vpc.connector, paramValues);
-                if (bdEndpoint.vpc.connector && !bdEndpoint.vpc.connector.includes("/")) {
-                    bdEndpoint.vpc.connector = `projects/${bdEndpoint.project}/locations/${region}/connectors/${bdEndpoint.vpc.connector}`;
+                bkEndpoint.vpc = {};
+                if (typeof bdEndpoint.vpc.connector !== "undefined" && bdEndpoint.vpc.connector !== null) {
+                    const connector = params.resolveString(bdEndpoint.vpc.connector, paramValues);
+                    bkEndpoint.vpc.connector =
+                        connector.includes("/") || connector === ""
+                            ? connector
+                            : `projects/${bdEndpoint.project}/locations/${region}/connectors/${connector}`;
                 }
-                bkEndpoint.vpc = { connector: bdEndpoint.vpc.connector };
                 if (bdEndpoint.vpc.egressSettings) {
-                    const egressSettings = r.resolveString(bdEndpoint.vpc.egressSettings);
-                    if (!backend.isValidEgressSetting(egressSettings)) {
-                        throw new error_1.FirebaseError(`Value "${egressSettings}" is an invalid ` +
-                            "egress setting. Valid values are PRIVATE_RANGES_ONLY and ALL_TRAFFIC");
+                    const egress = params.resolveString(bdEndpoint.vpc.egressSettings, paramValues);
+                    if (!backend.AllVpcEgressSettings.includes(egress)) {
+                        throw new error_1.FirebaseError(`Value "${egress}" is an invalid egress setting.`);
                     }
-                    bkEndpoint.vpc.egressSettings = egressSettings;
+                    bkEndpoint.vpc.egressSettings = egress;
+                }
+                if (bdEndpoint.vpc.networkInterfaces) {
+                    bkEndpoint.vpc.networkInterfaces = bdEndpoint.vpc.networkInterfaces.map((ni) => {
+                        const resolved = {};
+                        if (ni.network)
+                            resolved.network = params.resolveString(ni.network, paramValues);
+                        if (ni.subnetwork)
+                            resolved.subnetwork = params.resolveString(ni.subnetwork, paramValues);
+                        if (ni.tags) {
+                            resolved.tags = ni.tags.map((tag) => params.resolveString(tag, paramValues));
+                        }
+                        return resolved;
+                    });
                 }
             }
             else if (bdEndpoint.vpc === null) {

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -88,10 +88,16 @@ function assertBuildEndpoint(ep, id) {
     });
     if (ep.vpc) {
         (0, parsing_1.assertKeyTypes)(prefix + ".vpc", ep.vpc, {
-            connector: "string",
+            connector: "string?",
             egressSettings: (setting) => setting === null || build.AllVpcEgressSettings.includes(setting),
+            networkInterfaces: "array?",
         });
-        (0, parsing_1.requireKeys)(prefix + ".vpc", ep.vpc, "connector");
+        if (!ep.vpc.connector && !ep.vpc.networkInterfaces) {
+            throw new error_1.FirebaseError(`VPC settings on ${id} must specify either 'connector' or 'networkInterfaces'`);
+        }
+        if (ep.vpc.connector && ep.vpc.networkInterfaces) {
+            throw new error_1.FirebaseError(`VPC settings on ${id} cannot specify both 'connector' and 'networkInterfaces'`);
+        }
     }
     let triggerCount = 0;
     if (ep.httpsTrigger) {

package/lib/emulator/apphosting/config.js

@@ -1,27 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalAppHostingConfiguration = getLocalAppHostingConfiguration;
-const path_1 = require("path");
 const config_1 = require("../../apphosting/config");
-const yaml_1 = require("../../apphosting/yaml");
 async function getLocalAppHostingConfiguration(backendDir) {
-    const appHostingConfigPaths = (0, config_1.listAppHostingFilesInPath)(backendDir);
-    const fileNameToPathMap = Object.fromEntries(appHostingConfigPaths.map((path) => [(0, path_1.basename)(path), path]));
-    const output = yaml_1.AppHostingYamlConfig.empty();
-    const baseFilePath = fileNameToPathMap[config_1.APPHOSTING_BASE_YAML_FILE];
-    const emulatorsFilePath = fileNameToPathMap[config_1.APPHOSTING_EMULATORS_YAML_FILE];
-    const localFilePath = fileNameToPathMap[config_1.APPHOSTING_LOCAL_YAML_FILE];
-    if (baseFilePath) {
-        const baseFile = await yaml_1.AppHostingYamlConfig.loadFromFile(baseFilePath);
-        output.merge(baseFile, false);
-    }
-    if (emulatorsFilePath) {
-        const emulatorsConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(emulatorsFilePath);
-        output.merge(emulatorsConfig, false);
-    }
-    if (localFilePath) {
-        const localYamlConfig = await yaml_1.AppHostingYamlConfig.loadFromFile(localFilePath);
-        output.merge(localYamlConfig, true);
-    }
-    return output;
+    return (0, config_1.getAppHostingConfiguration)(backendDir);
 }

package/lib/emulator/controller.js

@@ -753,7 +753,8 @@ async function exportEmulatorData(exportPath, options, initiatedBy) {
     }
     utils.logBullet(`Exporting data to: ${exportAbsPath}`);
     try {
-        await hubClient.postExport({ path: exportAbsPath, initiatedBy });
+        const targets = filterEmulatorTargets(options);
+        await hubClient.postExport({ path: exportAbsPath, initiatedBy, targets });
     }
     catch (e) {
         throw new error_1.FirebaseError("Export request failed, see emulator logs for more information.", {

package/lib/emulator/hub.js

@@ -71,11 +71,13 @@ class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
             }
             const path = req.body.path;
             const initiatedBy = req.body.initiatedBy || "unknown";
+            const targets = req.body.targets;
             utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${path}.`);
             try {
                 await new hubExport_1.HubExport(this.args.projectId, {
                     path,
                     initiatedBy,
+                    targets,
                 }).exportAll();
                 utils.logLabeledSuccess("emulators", "Export complete.");
                 res.status(200).send({