firebase-tools 15.4.0 → 15.5.0

package/lib/apiv2.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.STANDARD_HEADERS = void 0;
+exports.Client = exports.CLI_OAUTH_PROJECT_NUMBER = exports.STANDARD_HEADERS = void 0;
 exports.setRefreshToken = setRefreshToken;
 exports.setAccessToken = setAccessToken;
 exports.getAccessToken = getAccessToken;
@@ -31,6 +31,7 @@ exports.STANDARD_HEADERS = {
 const GOOG_QUOTA_USER_HEADER = "x-goog-quota-user";
 const GOOG_USER_PROJECT_HEADER = "x-goog-user-project";
 const GOOGLE_CLOUD_QUOTA_PROJECT = process.env.GOOGLE_CLOUD_QUOTA_PROJECT;
+exports.CLI_OAUTH_PROJECT_NUMBER = "563584335869";
 let accessToken = "";
 let refreshToken = "";
 function setRefreshToken(token = "") {
@@ -128,6 +129,10 @@ class Client {
             return await this.doRequest(internalReqOptions);
         }
         catch (thrown) {
+            const originalErrorMessage = thrown.original?.message || thrown.message || "";
+            if (originalErrorMessage.includes(exports.CLI_OAUTH_PROJECT_NUMBER)) {
+                throw new error_1.FirebaseError("An Internal error has occurred. Please try again in a few minutes. If this error persists, please open an issue at https://github.com/firebase/firebase-tools", { original: thrown });
+            }
             if (thrown instanceof error_1.FirebaseError) {
                 throw thrown;
             }

package/lib/appdistribution/client.js

@@ -225,7 +225,7 @@ class AppDistributionClient {
         }
         utils.logSuccess(`Testers removed from group successfully`);
     }
-    async createReleaseTest(releaseName, devices, aiInstruction, loginCredential, testCaseName) {
+    async createReleaseTest(releaseName, devices, aiInstruction, loginCredential, testCaseName, displayName) {
         try {
             const response = await this.appDistroV1AlphaClient.request({
                 method: "POST",
@@ -235,6 +235,7 @@ class AppDistributionClient {
                     loginCredential,
                     testCase: testCaseName,
                     aiInstructions: aiInstruction,
+                    displayName: displayName,
                 },
             });
             return response.body;

package/lib/apptesting/parseTestFiles.js

@@ -7,67 +7,115 @@ const logger_1 = require("../logger");
 const types_1 = require("./types");
 const utils_1 = require("../utils");
 const error_1 = require("../error");
-function createFilter(pattern) {
-    const regex = pattern ? new RegExp(pattern) : undefined;
-    return (s) => !regex || regex.test(s);
-}
 async function parseTestFiles(dir, targetUri, filePattern, namePattern) {
-    try {
-        new URL(targetUri);
-    }
-    catch (ex) {
-        const errMsg = "Invalid URL" + (targetUri.startsWith("http") ? "" : " (must include protocol)");
-        throw new error_1.FirebaseError(errMsg, { original: (0, error_1.getError)(ex) });
+    if (targetUri) {
+        try {
+            new URL(targetUri);
+        }
+        catch (ex) {
+            const errMsg = "Invalid URL" + (targetUri.startsWith("http") ? "" : " (must include protocol)");
+            throw new error_1.FirebaseError(errMsg, { original: (0, error_1.getError)(ex) });
+        }
     }
+    const files = await parseTestFilesRecursive({ testDir: dir, targetUri });
+    const idToInvocation = files
+        .flatMap((file) => file.invocations)
+        .reduce((accumulator, invocation) => {
+        if (invocation.testCase.id) {
+            accumulator[invocation.testCase.id] = invocation;
+        }
+        return accumulator;
+    }, {});
     const fileFilterFn = createFilter(filePattern);
     const nameFilterFn = createFilter(namePattern);
-    async function parseTestFilesRecursive(testDir) {
-        const items = (0, fsutils_1.listFiles)(testDir);
-        const results = [];
-        for (const item of items) {
-            const path = (0, path_1.join)(testDir, item);
-            if ((0, fsutils_1.dirExistsSync)(path)) {
-                results.push(...(await parseTestFilesRecursive(path)));
+    const filteredInvocations = files
+        .filter((file) => fileFilterFn(file.path))
+        .flatMap((file) => file.invocations)
+        .filter((invocation) => nameFilterFn(invocation.testCase.displayName));
+    return filteredInvocations.map((invocation) => {
+        let prerequisiteTestCaseId = invocation.testCase.prerequisiteTestCaseId;
+        if (prerequisiteTestCaseId === undefined) {
+            return invocation;
+        }
+        const prerequisiteSteps = [];
+        const previousTestCaseIds = new Set();
+        while (prerequisiteTestCaseId) {
+            if (previousTestCaseIds.has(prerequisiteTestCaseId)) {
+                throw new error_1.FirebaseError(`Detected a cycle in prerequisite test cases.`);
             }
-            else if (fileFilterFn(path) && (0, fsutils_1.fileExistsSync)(path)) {
-                try {
-                    const file = await (0, utils_1.readFileFromDirectory)(testDir, item);
-                    const parsedFile = (0, utils_1.wrappedSafeLoad)(file.source);
-                    const tests = parsedFile.tests;
-                    const defaultConfig = parsedFile.defaultConfig;
-                    if (!tests || !tests.length) {
-                        logger_1.logger.info(`No tests found in ${path}. Ignoring.`);
-                        continue;
-                    }
-                    for (const rawTestDef of parsedFile.tests) {
-                        if (!nameFilterFn(rawTestDef.testName))
-                            continue;
-                        const testDef = toTestDef(rawTestDef, targetUri, defaultConfig);
-                        results.push(testDef);
-                    }
-                }
-                catch (ex) {
-                    const errMsg = (0, error_1.getErrMsg)(ex);
-                    const errDetails = errMsg ? `Error details: \n${errMsg}` : "";
-                    logger_1.logger.info(`Unable to parse test file ${path}. Ignoring.${errDetails}`);
+            previousTestCaseIds.add(prerequisiteTestCaseId);
+            const prerequisiteTestCaseInvocation = idToInvocation[prerequisiteTestCaseId];
+            if (prerequisiteTestCaseInvocation === undefined) {
+                throw new error_1.FirebaseError(`Invalid prerequisiteTestCaseId. There is no test case with id ${prerequisiteTestCaseId}`);
+            }
+            prerequisiteSteps.unshift(...prerequisiteTestCaseInvocation.testCase.steps);
+            prerequisiteTestCaseId = prerequisiteTestCaseInvocation.testCase.prerequisiteTestCaseId;
+        }
+        return {
+            ...invocation,
+            testCase: {
+                ...invocation.testCase,
+                steps: prerequisiteSteps.concat(invocation.testCase.steps),
+            },
+        };
+    });
+}
+function createFilter(pattern) {
+    const regex = pattern ? new RegExp(pattern) : undefined;
+    return (s) => !regex || regex.test(s);
+}
+async function parseTestFilesRecursive(params) {
+    const testDir = params.testDir;
+    const targetUri = params.targetUri;
+    const items = (0, fsutils_1.listFiles)(testDir);
+    const results = [];
+    for (const item of items) {
+        const path = (0, path_1.join)(testDir, item);
+        if ((0, fsutils_1.dirExistsSync)(path)) {
+            results.push(...(await parseTestFilesRecursive({ testDir: path, targetUri })));
+        }
+        else if ((0, fsutils_1.fileExistsSync)(path)) {
+            try {
+                const file = await (0, utils_1.readFileFromDirectory)(testDir, item);
+                logger_1.logger.debug(`Read the file ${file.source}.`);
+                const parsedFile = (0, utils_1.wrappedSafeLoad)(file.source);
+                logger_1.logger.debug(`Parsed the file.`);
+                const tests = parsedFile.tests;
+                logger_1.logger.debug(`There are ${tests.length} tests.`);
+                const defaultConfig = parsedFile.defaultConfig;
+                if (!tests || !tests.length) {
+                    logger_1.logger.debug(`No tests found in ${path}. Ignoring.`);
                     continue;
                 }
+                const invocations = [];
+                for (const rawTestDef of tests) {
+                    const invocation = toTestCaseInvocation(rawTestDef, targetUri, defaultConfig);
+                    invocations.push(invocation);
+                }
+                results.push({ path, invocations: invocations });
+            }
+            catch (ex) {
+                const errMsg = (0, error_1.getErrMsg)(ex);
+                const errDetails = errMsg ? `Error details: \n${errMsg}` : "";
+                logger_1.logger.debug(`Unable to parse test file ${path}. Ignoring.${errDetails}`);
+                continue;
             }
         }
-        return results;
     }
-    return parseTestFilesRecursive(dir);
+    return results;
 }
-function toTestDef(testDef, targetUri, defaultConfig) {
+function toTestCaseInvocation(testDef, targetUri, defaultConfig) {
     const steps = testDef.steps ?? [];
     const route = testDef.testConfig?.route ?? defaultConfig?.route ?? "";
     const browsers = testDef.testConfig?.browsers ??
         defaultConfig?.browsers ?? [types_1.Browser.CHROME];
     return {
         testCase: {
+            id: testDef.id,
+            prerequisiteTestCaseId: testDef.prerequisiteTestCaseId,
             startUri: targetUri + route,
-            displayName: testDef.testName,
-            instructions: { steps },
+            displayName: testDef.displayName,
+            steps: steps,
         },
         testExecution: browsers.map((browser) => ({ config: { browser } })),
     };

package/lib/bin/cli.js

@@ -10,10 +10,11 @@ const fs = require("node:fs");
 const configstore_1 = require("../configstore");
 const errorOut_1 = require("../errorOut");
 const logger_1 = require("../logger");
+const experiments_1 = require("../experiments");
+(0, experiments_1.enableExperimentsFromCliEnvVariable)();
 const client = require("..");
 const fsutils = require("../fsutils");
 const utils = require("../utils");
-const experiments_1 = require("../experiments");
 const fetchMOTD_1 = require("../fetchMOTD");
 const command_1 = require("../command");
 function cli(pkg) {
@@ -36,7 +37,6 @@ function cli(pkg) {
     }
     logger_1.logger.debug("-".repeat(70));
     logger_1.logger.debug();
-    (0, experiments_1.enableExperimentsFromCliEnvVariable)();
     (0, fetchMOTD_1.fetchMOTD)();
     process.on("exit", (code) => {
         code = typeof process.exitCode === "number" ? process.exitCode : code;

package/lib/command.js

@@ -90,6 +90,9 @@ class Command {
             const start = process.uptime();
             const options = (0, lodash_1.last)(args);
             if (args.length - 1 > cmd._args.length) {
+                if (!(0, utils_1.getInheritedOption)(options, "json") && !options.isMCP) {
+                    (0, logger_1.useConsoleLoggers)();
+                }
                 client.errorOut(new error_1.FirebaseError(`Too many arguments. Run ${clc.bold("firebase help " + this.name)} for usage instructions`, { exit: 1 }));
                 return;
             }

package/lib/commands/apptesting.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const requireAuth_1 = require("../requireAuth");
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+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");
+const defaultDevices = [
+    {
+        model: "MediumPhone.arm",
+        version: "36",
+        locale: "en_US",
+        orientation: "portrait",
+    },
+];
+exports.command = new command_1.Command("apptesting:execute <release-binary-file>")
+    .description("Run mobile automated tests written in natural language driven by AI")
+    .option("--app <app_id>", "The app id of your Firebase web app. Optional if the project contains exactly one web app.")
+    .option("--test-file-pattern <pattern>", "Test file pattern. Only tests contained in files that match this pattern will be executed.")
+    .option("--test-name-pattern <pattern>", "Test name pattern. Only tests with names that match this pattern will be executed.")
+    .option("--test-dir <test_dir>", "Directory where tests can be found.")
+    .option("--test-devices <string>", "semicolon-separated list of devices to run automated tests on, in the format 'model=<model-id>,version=<os-version-id>,locale=<locale>,orientation=<orientation>'. Run 'gcloud firebase test android|ios models list' to see available devices. Note: This feature is in beta.")
+    .option("--test-devices-file <string>", "path to file containing a list of semicolon- or newline-separated devices to run automated tests on, in the format 'model=<model-id>,version=<os-version-id>,locale=<locale>,orientation=<orientation>'. Run 'gcloud firebase test android|ios models list' to see available devices. Note: This feature is in beta.")
+    .before(requireAuth_1.requireAuth)
+    .action(async (target, options) => {
+    const appName = (0, options_parser_util_1.getAppName)(options);
+    const testDir = options.testDir || "tests";
+    const tests = await (0, parseTestFiles_1.parseTestFiles)(testDir, undefined, options.testFilePattern, options.testNamePattern);
+    const testDevices = (0, options_parser_util_1.parseTestDevices)(options.testDevices, options.testDevicesFile);
+    if (!tests.length) {
+        throw new error_1.FirebaseError("No tests found");
+    }
+    const invokeSpinner = ora("Requesting test execution");
+    let testInvocations;
+    let releaseId;
+    try {
+        const client = new client_1.AppDistributionClient();
+        releaseId = await (0, distribution_1.upload)(client, appName, new distribution_1.Distribution(target));
+        invokeSpinner.start();
+        testInvocations = await invokeTests(client, releaseId, tests, !testDevices.length ? defaultDevices : testDevices);
+        invokeSpinner.text = "Test execution requested";
+        invokeSpinner.succeed();
+    }
+    catch (ex) {
+        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`));
+});
+function pluralizeTests(numTests) {
+    return `${numTests} test${numTests === 1 ? "" : "s"}`;
+}
+async function invokeTests(client, releaseName, testDefs, devices) {
+    try {
+        const testInvocations = [];
+        for (const testDef of testDefs) {
+            const aiInstruction = {
+                steps: testDef.testCase.steps,
+            };
+            testInvocations.push(await client.createReleaseTest(releaseName, devices, aiInstruction, undefined, undefined, testDef.testCase.displayName));
+        }
+        return testInvocations;
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Test invocation failed", { original: (0, error_1.getError)(err) });
+    }
+}

package/lib/commands/dataconnect-compile.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const command_1 = require("../command");
+const dataconnectEmulator_1 = require("../emulator/dataconnectEmulator");
+const projectUtils_1 = require("../projectUtils");
+const load_1 = require("../dataconnect/load");
+const auth_1 = require("../auth");
+const utils_1 = require("../utils");
+const hub_1 = require("../emulator/hub");
+const build_1 = require("../dataconnect/build");
+const error_1 = require("../error");
+exports.command = new command_1.Command("dataconnect:compile")
+    .description("compile your Data Connect schema and connector config and GQL files.")
+    .option("--service <serviceId>", "the serviceId of the Data Connect service. If not provided, compiles all services.")
+    .option("--location <location>", "the location of the Data Connect service. Only needed if service ID is used in multiple locations.")
+    .action(async (options) => {
+    const projectId = (0, projectUtils_1.getProjectId)(options);
+    const config = options.config;
+    if (!config || !config.has("dataconnect")) {
+        throw new error_1.FirebaseError(`No Data Connect project directory found. Please run ${clc.bold("firebase init dataconnect")} to set it up first.`);
+    }
+    const serviceInfos = await (0, load_1.pickServices)(projectId || hub_1.EmulatorHub.MISSING_PROJECT_PLACEHOLDER, config, options.service, options.location);
+    if (!serviceInfos.length) {
+        throw new error_1.FirebaseError("No Data Connect services found to compile.");
+    }
+    for (const serviceInfo of serviceInfos) {
+        const configDir = serviceInfo.sourceDirectory;
+        const account = (0, auth_1.getProjectDefaultAccount)(options.projectRoot);
+        const buildArgs = {
+            configDir,
+            projectId,
+            account,
+        };
+        const buildResult = await dataconnectEmulator_1.DataConnectEmulator.build(buildArgs);
+        if (buildResult?.errors?.length) {
+            await (0, build_1.handleBuildErrors)(buildResult.errors, options.nonInteractive, options.force, false);
+        }
+        await dataconnectEmulator_1.DataConnectEmulator.generate({
+            configDir,
+            account,
+        });
+        (0, utils_1.logLabeledSuccess)("dataconnect", `Successfully compiled Data Connect service: ${clc.bold(serviceInfo.dataConnectYaml.serviceId)}`);
+    }
+});

package/lib/commands/firestore-databases-create.js

@@ -17,6 +17,9 @@ exports.command = new command_1.Command("firestore:databases:create <database>")
     .option("--edition <edition>", "the edition of the database to create, for example 'standard' or 'enterprise'. If not provided, 'standard' is used as a default.")
     .option("--delete-protection <deleteProtectionState>", "whether or not to prevent deletion of database, for example 'ENABLED' or 'DISABLED'. Default is 'DISABLED'")
     .option("--point-in-time-recovery <enablement>", "whether to enable the PITR feature on this database, for example 'ENABLED' or 'DISABLED'. Default is 'DISABLED'")
+    .option("--realtime-updates <enablement>", "Whether realtime updates are enabled for this database, for example 'ENABLED' or 'DISABLED'. Can only be specified for 'enterprise' edition databases. Defaults to 'ENABLED' when firestore-data-access is enabled, otherwise the server default is used.")
+    .option("--firestore-data-access <enablement>", "Whether the Firestore API can be used for this database, for example 'ENABLED' or 'DISABLED'. Can only be specified for 'enterprise' edition databases. Default is 'ENABLED'.")
+    .option("--mongodb-compatible-data-access <enablement>", "Whether the MongoDB compatible API can be used for this database, for example 'ENABLED' or 'DISABLED'. Can only be specified for 'enterprise' edition databases. Default is 'DISABLED'.")
     .option("-k, --kms-key-name <kmsKeyName>", "the resource ID of a Cloud KMS key. If set, the database created will be a " +
     "Customer-managed Encryption Key (CMEK) database encrypted with this key. " +
     "This feature is allowlist only in initial launch")
@@ -39,22 +42,51 @@ exports.command = new command_1.Command("firestore:databases:create <database>")
         }
         databaseEdition = edition;
     }
-    if (options.deleteProtection &&
-        options.deleteProtection !== types.DatabaseDeleteProtectionStateOption.ENABLED &&
-        options.deleteProtection !== types.DatabaseDeleteProtectionStateOption.DISABLED) {
-        throw new error_1.FirebaseError(`Invalid value for flag --delete-protection. ${helpCommandText}`);
-    }
-    const deleteProtectionState = options.deleteProtection === types.DatabaseDeleteProtectionStateOption.ENABLED
+    types.validateEnablementOption(options.deleteProtection, "delete-protection", helpCommandText);
+    const deleteProtectionState = options.deleteProtection === types.EnablementOption.ENABLED
         ? types.DatabaseDeleteProtectionState.ENABLED
         : types.DatabaseDeleteProtectionState.DISABLED;
-    if (options.pointInTimeRecovery &&
-        options.pointInTimeRecovery !== types.PointInTimeRecoveryEnablementOption.ENABLED &&
-        options.pointInTimeRecovery !== types.PointInTimeRecoveryEnablementOption.DISABLED) {
-        throw new error_1.FirebaseError(`Invalid value for flag --point-in-time-recovery. ${helpCommandText}`);
-    }
-    const pointInTimeRecoveryEnablement = options.pointInTimeRecovery === types.PointInTimeRecoveryEnablementOption.ENABLED
+    types.validateEnablementOption(options.pointInTimeRecovery, "point-in-time-recovery", helpCommandText);
+    const pointInTimeRecoveryEnablement = options.pointInTimeRecovery === types.EnablementOption.ENABLED
         ? types.PointInTimeRecoveryEnablement.ENABLED
         : types.PointInTimeRecoveryEnablement.DISABLED;
+    types.validateEnablementOption(options.firestoreDataAccess, "firestore-data-access", helpCommandText);
+    let userFirestoreDataAccess;
+    if (options.firestoreDataAccess === types.EnablementOption.ENABLED) {
+        userFirestoreDataAccess = types.DataAccessMode.ENABLED;
+    }
+    else if (options.firestoreDataAccess === types.EnablementOption.DISABLED) {
+        userFirestoreDataAccess = types.DataAccessMode.DISABLED;
+    }
+    types.validateEnablementOption(options.mongodbCompatibleDataAccess, "mongodb-compatible-data-access", helpCommandText);
+    let userMongodbDataAccess;
+    if (options.mongodbCompatibleDataAccess === types.EnablementOption.ENABLED) {
+        userMongodbDataAccess = types.DataAccessMode.ENABLED;
+    }
+    else if (options.mongodbCompatibleDataAccess === types.EnablementOption.DISABLED) {
+        userMongodbDataAccess = types.DataAccessMode.DISABLED;
+    }
+    let firestoreDataAccessMode = userFirestoreDataAccess;
+    if (firestoreDataAccessMode == null) {
+        firestoreDataAccessMode = getDefaultFirestoreDataAccessMode(databaseEdition, userMongodbDataAccess);
+    }
+    let mongodbCompatibleDataAccessMode = userMongodbDataAccess;
+    if (mongodbCompatibleDataAccessMode == null) {
+        mongodbCompatibleDataAccessMode = getDefaultMongodbDataAccessMode(databaseEdition, userFirestoreDataAccess);
+    }
+    types.validateEnablementOption(options.realtimeUpdates, "realtime-updates", helpCommandText);
+    let realtimeUpdatesMode;
+    if (options.realtimeUpdates === types.EnablementOption.ENABLED) {
+        realtimeUpdatesMode = types.RealtimeUpdatesMode.ENABLED;
+    }
+    else if (options.realtimeUpdates === types.EnablementOption.DISABLED) {
+        realtimeUpdatesMode = types.RealtimeUpdatesMode.DISABLED;
+    }
+    if (realtimeUpdatesMode == null &&
+        databaseEdition === types.DatabaseEdition.ENTERPRISE &&
+        firestoreDataAccessMode === types.DataAccessMode.ENABLED) {
+        realtimeUpdatesMode = types.RealtimeUpdatesMode.ENABLED;
+    }
     let cmekConfig;
     if (options.kmsKeyName) {
         cmekConfig = {
@@ -69,6 +101,9 @@ exports.command = new command_1.Command("firestore:databases:create <database>")
         databaseEdition,
         deleteProtectionState,
         pointInTimeRecoveryEnablement,
+        realtimeUpdatesMode,
+        firestoreDataAccessMode,
+        mongodbCompatibleDataAccessMode,
         cmekConfig,
     };
     const databaseResp = await api.createDatabase(createDatabaseReq);
@@ -79,3 +114,25 @@ exports.command = new command_1.Command("firestore:databases:create <database>")
     logger_1.logger.info(`Your database may be viewed at ${printer.firebaseConsoleDatabaseUrl(options.project, database)}`);
     return databaseResp;
 });
+function getDefaultFirestoreDataAccessMode(databaseEdition, userMongodbDataAccess) {
+    if (databaseEdition !== types.DatabaseEdition.ENTERPRISE) {
+        return types.DataAccessMode.UNSPECIFIED;
+    }
+    switch (userMongodbDataAccess) {
+        case types.DataAccessMode.ENABLED:
+            return types.DataAccessMode.DISABLED;
+        default:
+            return types.DataAccessMode.ENABLED;
+    }
+}
+function getDefaultMongodbDataAccessMode(databaseEdition, userFirestoreDataAccess) {
+    if (databaseEdition !== types.DatabaseEdition.ENTERPRISE) {
+        return types.DataAccessMode.UNSPECIFIED;
+    }
+    switch (userFirestoreDataAccess) {
+        case types.DataAccessMode.ENABLED:
+            return types.DataAccessMode.DISABLED;
+        default:
+            return types.DataAccessMode.DISABLED;
+    }
+}

package/lib/commands/firestore-databases-update.js

@@ -25,28 +25,20 @@ exports.command = new command_1.Command("firestore:databases:update <database>")
     if (!options.deleteProtection && !options.pointInTimeRecovery) {
         throw new error_1.FirebaseError(`Missing properties to update. ${helpCommandText}`);
     }
-    if (options.deleteProtection &&
-        options.deleteProtection !== types.DatabaseDeleteProtectionStateOption.ENABLED &&
-        options.deleteProtection !== types.DatabaseDeleteProtectionStateOption.DISABLED) {
-        throw new error_1.FirebaseError(`Invalid value for flag --delete-protection. ${helpCommandText}`);
-    }
+    types.validateEnablementOption(options.deleteProtection, "delete-protection", helpCommandText);
     let deleteProtectionState;
-    if (options.deleteProtection === types.DatabaseDeleteProtectionStateOption.ENABLED) {
+    if (options.deleteProtection === types.EnablementOption.ENABLED) {
         deleteProtectionState = types.DatabaseDeleteProtectionState.ENABLED;
     }
-    else if (options.deleteProtection === types.DatabaseDeleteProtectionStateOption.DISABLED) {
+    else if (options.deleteProtection === types.EnablementOption.DISABLED) {
         deleteProtectionState = types.DatabaseDeleteProtectionState.DISABLED;
     }
-    if (options.pointInTimeRecovery &&
-        options.pointInTimeRecovery !== types.PointInTimeRecoveryEnablementOption.ENABLED &&
-        options.pointInTimeRecovery !== types.PointInTimeRecoveryEnablementOption.DISABLED) {
-        throw new error_1.FirebaseError(`Invalid value for flag --point-in-time-recovery. ${helpCommandText}`);
-    }
+    types.validateEnablementOption(options.pointInTimeRecovery, "point-in-time-recovery", helpCommandText);
     let pointInTimeRecoveryEnablement;
-    if (options.pointInTimeRecovery === types.PointInTimeRecoveryEnablementOption.ENABLED) {
+    if (options.pointInTimeRecovery === types.EnablementOption.ENABLED) {
         pointInTimeRecoveryEnablement = types.PointInTimeRecoveryEnablement.ENABLED;
     }
-    else if (options.pointInTimeRecovery === types.PointInTimeRecoveryEnablementOption.DISABLED) {
+    else if (options.pointInTimeRecovery === types.EnablementOption.DISABLED) {
         pointInTimeRecoveryEnablement = types.PointInTimeRecoveryEnablement.DISABLED;
     }
     const databaseResp = await api.updateDatabase(options.project, database, deleteProtectionState, pointInTimeRecoveryEnablement);

package/lib/commands/index.js

@@ -244,6 +244,7 @@ function load(client) {
     client.dataconnect.sql.migrate = loadCommand("dataconnect-sql-migrate");
     client.dataconnect.sql.grant = loadCommand("dataconnect-sql-grant");
     client.dataconnect.sql.shell = loadCommand("dataconnect-sql-shell");
+    client.dataconnect.compile = loadCommand("dataconnect-compile");
     client.dataconnect.sdk = {};
     client.dataconnect.sdk.generate = loadCommand("dataconnect-sdk-generate");
     client.target = loadCommand("target");
@@ -253,6 +254,7 @@ function load(client) {
     client.use = loadCommand("use");
     if (experiments.isEnabled("apptesting")) {
         client.apptesting = {};
+        client.apptesting.execute = loadCommand("apptesting");
         client.apptesting.wata = loadCommand("apptesting-wata");
     }
     const t1 = process.hrtime.bigint();

package/lib/dataconnect/client.js

@@ -114,7 +114,7 @@ async function upsertSchema(schema, validateOnly = false, async = false) {
         apiOrigin: (0, api_1.dataconnectOrigin)(),
         apiVersion: DATACONNECT_API_VERSION,
         operationResourceName: op.body.name,
-        masterTimeout: 10000,
+        masterTimeout: 60000,
     });
 }
 async function deleteSchema(serviceName) {
@@ -163,6 +163,7 @@ async function upsertConnector(connector) {
         apiOrigin: (0, api_1.dataconnectOrigin)(),
         apiVersion: DATACONNECT_API_VERSION,
         operationResourceName: op.body.name,
+        masterTimeout: 60000,
     });
     return pollRes;
 }

package/lib/deploy/functions/prepare.js

@@ -205,6 +205,7 @@ async function prepare(context, options, payload) {
     await (0, checkIam_1.ensureGenkitMonitoringRoles)(projectId, projectNumber, matchingBackend, haveBackend, options.dryRun);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend, options.dryRun);
     updateEndpointTargetedStatus(wantBackends, context.filters || []);
+    validate.checkFiltersIntegrity(wantBackends, context.filters);
     (0, applyHash_1.applyBackendHashToBackends)(wantBackends, context);
 }
 function inferDetailsFromExisting(want, have, usedDotenv) {

package/lib/deploy/functions/validate.js

@@ -8,6 +8,7 @@ exports.endpointsAreUnique = endpointsAreUnique;
 exports.functionsDirectoryExists = functionsDirectoryExists;
 exports.functionIdsAreValid = functionIdsAreValid;
 exports.secretsAreValid = secretsAreValid;
+exports.checkFiltersIntegrity = checkFiltersIntegrity;
 const path = require("path");
 const clc = require("colorette");
 const error_1 = require("../../error");
@@ -257,3 +258,27 @@ async function validateSecretVersions(projectId, endpoints) {
         }
     }
 }
+function checkFiltersIntegrity(wantBackends, filters) {
+    if (!filters) {
+        return;
+    }
+    for (const filter of filters) {
+        let matched = false;
+        for (const b of Object.values(wantBackends)) {
+            if (backend.someEndpoint(b, (e) => (0, functionsDeployHelper_1.endpointMatchesFilter)(e, filter))) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            const parts = [];
+            if (filter.codebase) {
+                parts.push(filter.codebase);
+            }
+            if (filter.idChunks) {
+                parts.push(filter.idChunks.join("-"));
+            }
+            throw new error_1.FirebaseError(`No function matches the filter: ${parts.join(":")}`);
+        }
+    }
+}

package/lib/emulator/auth/operations.js

@@ -2243,8 +2243,8 @@ function generateBlockingFunctionJwt(state, event, url, timeoutMs, user, options
     }
     if (user.lastLoginAt || user.createdAt) {
         jwt.user_record.metadata = {
-            last_sign_in_time: user.lastLoginAt,
-            creation_time: user.createdAt,
+            last_sign_in_time: user.lastLoginAt ? parseInt(user.lastLoginAt) : undefined,
+            creation_time: user.createdAt ? parseInt(user.createdAt) : undefined,
         };
     }
     if (state.shouldForwardCredentialToBlockingFunction("accessToken")) {