firebase-tools 15.10.1 → 15.12.0

package/lib/emulator/functionsEmulator.js

@@ -35,6 +35,8 @@ const v1_1 = require("../functions/events/v1");
 const build_1 = require("../deploy/functions/build");
 const env_1 = require("./env");
 const python_1 = require("../functions/python");
+const supported_1 = require("../deploy/functions/runtimes/supported");
+const dart_1 = require("../deploy/functions/runtimes/dart");
 const EVENT_INVOKE_GA4 = "functions_invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class IPCConn {
@@ -83,6 +85,7 @@ class FunctionsEmulator {
         this.staticBackends = [];
         this.dynamicBackends = [];
         this.watchers = [];
+        this.watchCleanups = [];
         this.debugMode = false;
         this.staticBackends = args.emulatableBackends;
         emulatorLogger_1.EmulatorLogger.setVerbosity(this.args.verbosity ? emulatorLogger_1.Verbosity[this.args.verbosity] : emulatorLogger_1.Verbosity["DEBUG"]);
@@ -208,7 +211,7 @@ class FunctionsEmulator {
     async sendRequest(trigger, body) {
         const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
         const pool = this.workerPools[record.backend.codebase];
-        if (!pool.readyForWork(trigger.id)) {
+        if (!pool.readyForWork(trigger.id, record.backend.runtime)) {
             try {
                 await this.startRuntime(record.backend, trigger);
             }
@@ -217,7 +220,7 @@ class FunctionsEmulator {
                 return;
             }
         }
-        const worker = pool.getIdleWorker(trigger.id);
+        const worker = pool.getIdleWorker(trigger.id, record.backend.runtime);
         if (this.debugMode) {
             await worker.sendDebugMsg({
                 functionTarget: trigger.entryPoint,
@@ -229,10 +232,13 @@ class FunctionsEmulator {
             "Content-Type": "application/json",
             "Content-Length": `${reqBody.length}`,
         };
+        const isDart = (0, supported_1.isLanguageRuntime)(record.backend.runtime, "dart");
+        const path = isDart ? `/${trigger.entryPoint}` : `/`;
         return new Promise((resolve, reject) => {
             const req = http.request({
                 ...worker.runtime.conn.httpReqOpts(),
-                path: `/`,
+                method: "POST",
+                path: path,
                 headers: headers,
             }, resolve);
             req.on("error", reject);
@@ -264,23 +270,43 @@ class FunctionsEmulator {
     async connect() {
         for (const backend of this.staticBackends) {
             this.logger.logLabeled("BULLET", "functions", `Watching "${backend.functionsDir}" for Cloud Functions...`);
-            const watcher = chokidar.watch(backend.functionsDir, {
-                ignored: [
-                    /.+?[\\\/]node_modules[\\\/].+?/,
-                    /(^|[\/\\])\../,
-                    /.+\.log/,
-                    /.+?[\\\/]venv[\\\/].+?/,
-                    ...(backend.ignore?.map((i) => `**/${i}`) ?? []),
-                ],
-                persistent: true,
-            });
-            this.watchers.push(watcher);
-            const debouncedLoadTriggers = (0, utils_1.debounce)(() => this.loadTriggers(backend), 1000);
-            watcher.on("change", (filePath) => {
-                this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
-                return debouncedLoadTriggers();
-            });
             await this.loadTriggers(backend, true);
+            const isDart = (0, supported_1.isLanguageRuntime)(backend.runtime, "dart");
+            if (isDart) {
+                const runtimeDelegateContext = {
+                    projectId: this.args.projectId,
+                    projectDir: this.args.projectDir,
+                    sourceDir: backend.functionsDir,
+                    runtime: backend.runtime,
+                };
+                const delegate = await runtimes.getRuntimeDelegate(runtimeDelegateContext);
+                this.logger.logLabeled("BULLET", "functions", `Starting build_runner watch for Dart functions...`);
+                const debouncedLoadTriggers = (0, utils_1.debounce)(() => this.loadTriggers(backend), 1000);
+                const cleanup = await delegate.watch(() => {
+                    this.logger.log("DEBUG", "build_runner rebuilt, reloading triggers");
+                    debouncedLoadTriggers();
+                });
+                this.watchCleanups.push(cleanup);
+                this.logger.logLabeled("SUCCESS", "functions", `build_runner initial build completed`);
+            }
+            else {
+                const watcher = chokidar.watch(backend.functionsDir, {
+                    ignored: [
+                        /(^|[\/\\])\../,
+                        /.+\.log/,
+                        /.+?[\\\/]node_modules[\\\/].+?/,
+                        /.+?[\\\/]venv[\\\/].+?/,
+                        ...(backend.ignore?.map((i) => `**/${i}`) ?? []),
+                    ],
+                    persistent: true,
+                });
+                this.watchers.push(watcher);
+                const debouncedLoadTriggers = (0, utils_1.debounce)(() => this.loadTriggers(backend), 1000);
+                watcher.on("change", (filePath) => {
+                    this.logger.log("DEBUG", `File ${filePath} changed, reloading triggers`);
+                    return debouncedLoadTriggers();
+                });
+            }
         }
         await this.performPostLoadOperations();
         return;
@@ -300,6 +326,10 @@ class FunctionsEmulator {
             await watcher.close();
         }
         this.watchers = [];
+        for (const cleanup of this.watchCleanups) {
+            await cleanup();
+        }
+        this.watchCleanups = [];
         if (this.destroyServer) {
             await this.destroyServer();
         }
@@ -1098,13 +1128,52 @@ class FunctionsEmulator {
             conn: new TCPConn("127.0.0.1", port),
         };
     }
+    async startDart(backend, envs) {
+        if (this.debugMode) {
+            this.logger.log("WARN", "--inspect-functions not supported for Dart functions. Ignored.");
+        }
+        const port = await portfinder.getPortPromise({
+            port: 8081 + (0, utils_1.randomInt)(0, 1000),
+        });
+        const args = ["run", "--no-serve-devtools", dart_1.DART_ENTRY_POINT];
+        const dartEnvs = { ...envs };
+        delete dartEnvs.FUNCTION_TARGET;
+        delete dartEnvs.FUNCTION_SIGNATURE_TYPE;
+        const bin = backend.bin || "dart";
+        logger_1.logger.debug(`Starting Dart runtime with args: ${args.join(" ")} on port ${port}`);
+        const childProcess = spawn(bin, args, {
+            cwd: backend.functionsDir,
+            env: {
+                ...process.env,
+                ...dartEnvs,
+                HOST: "127.0.0.1",
+                PORT: port.toString(),
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        childProcess.stdout?.on("data", (chunk) => {
+            this.logger.log("DEBUG", `[dart] ${chunk.toString("utf8")}`);
+        });
+        childProcess.stderr?.on("data", (chunk) => {
+            this.logger.log("DEBUG", `[dart] ${chunk.toString("utf8")}`);
+        });
+        return {
+            process: childProcess,
+            events: new events_1.EventEmitter(),
+            cwd: backend.functionsDir,
+            conn: new TCPConn("127.0.0.1", port),
+        };
+    }
     async startRuntime(backend, trigger) {
         const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
         const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
         let runtime;
-        if (backend.runtime.startsWith("python")) {
+        if ((0, supported_1.isLanguageRuntime)(backend.runtime, "python")) {
             runtime = await this.startPython(backend, { ...runtimeEnv, ...secretEnvs });
         }
+        else if ((0, supported_1.isLanguageRuntime)(backend.runtime, "dart")) {
+            runtime = await this.startDart(backend, { ...runtimeEnv, ...secretEnvs });
+        }
         else {
             runtime = await this.startNode(backend, { ...runtimeEnv, ...secretEnvs });
         }
@@ -1113,7 +1182,7 @@ class FunctionsEmulator {
             ref: backend.extensionVersion?.ref,
         };
         const pool = this.workerPools[backend.codebase];
-        const worker = pool.addWorker(trigger, runtime, extensionLogInfo);
+        const worker = pool.addWorker(trigger, runtime, extensionLogInfo, backend.runtime);
         await worker.waitForSocketReady();
         return worker;
     }
@@ -1172,10 +1241,20 @@ class FunctionsEmulator {
         });
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         const url = new url_1.URL(`${req.protocol}://${req.hostname}${req.url}`);
-        const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${req.params.trigger_name}\/?`), "/");
+        let path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${req.params.trigger_name}\/?`), "/");
+        const isDart = (0, supported_1.isLanguageRuntime)(record.backend.runtime, "dart");
+        if (isDart) {
+            const isBackgroundRoute = req.url.startsWith("/functions/projects/");
+            if (isBackgroundRoute || path === "/") {
+                path = `/${trigger.entryPoint}`;
+            }
+            else {
+                path = `/${trigger.entryPoint}${path}`;
+            }
+        }
         this.logger.log("DEBUG", `[functions] Got req.url=${req.url}, mapping to path=${path}`);
         const pool = this.workerPools[record.backend.codebase];
-        if (!pool.readyForWork(trigger.id)) {
+        if (!pool.readyForWork(trigger.id, record.backend.runtime)) {
             try {
                 await this.startRuntime(record.backend, trigger);
             }
@@ -1196,7 +1275,7 @@ class FunctionsEmulator {
             method,
             path,
             headers: req.headers,
-        }, res, reqBody, debugBundle);
+        }, res, reqBody, debugBundle, record.backend.runtime);
     }
 }
 exports.FunctionsEmulator = FunctionsEmulator;

package/lib/emulator/functionsRuntimeWorker.js

@@ -8,6 +8,7 @@ const events_1 = require("events");
 const emulatorLogger_1 = require("./emulatorLogger");
 const error_1 = require("../error");
 const discovery_1 = require("../deploy/functions/runtimes/discovery");
+const supported_1 = require("../deploy/functions/runtimes/supported");
 var RuntimeWorkerState;
 (function (RuntimeWorkerState) {
     RuntimeWorkerState["CREATED"] = "CREATED";
@@ -226,13 +227,14 @@ class RuntimeWorkerPool {
         this.mode = mode;
         this.workers = new Map();
     }
-    getKey(triggerId) {
+    getKey(triggerId, runtime) {
         if (this.mode === types_1.FunctionsExecutionMode.SEQUENTIAL) {
             return "~shared~";
         }
-        else {
-            return triggerId || "~diagnostic~";
+        if ((0, supported_1.isLanguageRuntime)(runtime, "dart")) {
+            return "~dart-shared~";
         }
+        return triggerId || "~diagnostic~";
     }
     refresh() {
         for (const arr of this.workers.values()) {
@@ -261,13 +263,13 @@ class RuntimeWorkerPool {
             });
         }
     }
-    readyForWork(triggerId) {
-        const idleWorker = this.getIdleWorker(triggerId);
+    readyForWork(triggerId, runtime) {
+        const idleWorker = this.getIdleWorker(triggerId, runtime);
         return !!idleWorker;
     }
-    async submitRequest(triggerId, req, resp, body, debug) {
+    async submitRequest(triggerId, req, resp, body, debug, runtime) {
         this.log(`submitRequest(triggerId=${triggerId})`);
-        const worker = this.getIdleWorker(triggerId);
+        const worker = this.getIdleWorker(triggerId, runtime);
         if (!worker) {
             throw new error_1.FirebaseError("Internal Error: can't call submitRequest without checking for idle workers");
         }
@@ -276,11 +278,11 @@ class RuntimeWorkerPool {
         }
         return worker.request(req, resp, body, !!debug);
     }
-    getIdleWorker(triggerId) {
+    getIdleWorker(triggerId, runtime) {
         this.cleanUpWorkers();
-        const triggerWorkers = this.getTriggerWorkers(triggerId);
+        const triggerWorkers = this.getTriggerWorkers(triggerId, runtime);
         if (!triggerWorkers.length) {
-            this.setTriggerWorkers(triggerId, []);
+            this.setTriggerWorkers(triggerId, [], runtime);
             return;
         }
         for (const worker of triggerWorkers) {
@@ -290,21 +292,22 @@ class RuntimeWorkerPool {
         }
         return;
     }
-    addWorker(trigger, runtime, extensionLogInfo) {
-        this.log(`addWorker(${this.getKey(trigger?.id)})`);
+    addWorker(trigger, runtime, extensionLogInfo, runtimeType) {
+        const key = this.getKey(trigger?.id, runtimeType);
+        this.log(`addWorker(${key})`);
         const disableTimeout = !trigger?.id || this.mode === types_1.FunctionsExecutionMode.SEQUENTIAL;
         const worker = new RuntimeWorker(trigger?.id, runtime, extensionLogInfo, disableTimeout ? undefined : trigger?.timeoutSeconds);
-        const keyWorkers = this.getTriggerWorkers(trigger?.id);
+        const keyWorkers = this.getTriggerWorkers(trigger?.id, runtimeType);
         keyWorkers.push(worker);
-        this.setTriggerWorkers(trigger?.id, keyWorkers);
+        this.setTriggerWorkers(trigger?.id, keyWorkers, runtimeType);
         this.log(`Adding worker with key ${worker.triggerKey}, total=${keyWorkers.length}`);
         return worker;
     }
-    getTriggerWorkers(triggerId) {
-        return this.workers.get(this.getKey(triggerId)) || [];
+    getTriggerWorkers(triggerId, runtime) {
+        return this.workers.get(this.getKey(triggerId, runtime)) || [];
     }
-    setTriggerWorkers(triggerId, workers) {
-        this.workers.set(this.getKey(triggerId), workers);
+    setTriggerWorkers(triggerId, workers, runtime) {
+        this.workers.set(this.getKey(triggerId, runtime), workers);
     }
     cleanUpWorkers() {
         for (const [key, keyWorkers] of this.workers.entries()) {

package/lib/emulator/storage/rules/manager.js

@@ -34,9 +34,16 @@ class DefaultStorageRulesManager {
             .watch(rulesFile, { persistent: true, ignoreInitial: true })
             .on("change", async () => {
             await new Promise((res) => setTimeout(res, 5));
-            this._logger.logLabeled("BULLET", "storage", "Change detected, updating rules for Cloud Storage...");
-            this._rules.content = (0, fsutils_1.readFile)(rulesFile);
-            await this.loadRuleset();
+            try {
+                const content = (0, fsutils_1.readFile)(rulesFile);
+                this._rules.content = content;
+                this._logger.logLabeled("BULLET", "storage", "Change detected, updating rules for Cloud Storage...");
+                await this.loadRuleset();
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                this._logger.logLabeled("DEBUG", "storage", `A rule file change was detected, but there was an error reading it: ${message}`);
+            }
         });
     }
     async loadRuleset() {

package/lib/emulator/storage/rules/runtime.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageRulesRuntime = exports.StorageRulesIssues = exports.StorageRulesetInstance = void 0;
+exports.createAuthExpressionValue = createAuthExpressionValue;
 const cross_spawn_1 = require("cross-spawn");
 const error_1 = require("../../../error");
 const AsyncLock = require("async-lock");
@@ -332,14 +333,15 @@ function createAuthExpressionValue(opts) {
     if (!opts.token) {
         return toExpressionValue(null);
     }
-    else {
-        const tokenPayload = jwt.decode(opts.token, { json: true });
-        const jsonValue = {
-            uid: tokenPayload.user_id,
-            token: tokenPayload,
-        };
-        return toExpressionValue(jsonValue);
+    const tokenPayload = jwt.decode(opts.token, { json: true });
+    if (typeof tokenPayload !== "object" || !tokenPayload) {
+        return toExpressionValue(null);
     }
+    const jsonValue = {
+        uid: "user_id" in tokenPayload ? tokenPayload.user_id : undefined,
+        token: tokenPayload,
+    };
+    return toExpressionValue(jsonValue);
 }
 function createRequestExpressionValue(opts) {
     const fields = {

package/lib/experiments.js

@@ -58,10 +58,22 @@ exports.ALL_EXPERIMENTS = experiments({
         shortDescription: "Functions created using the V2 API target Cloud Run Functions (not production ready)",
         public: false,
     },
+    functionsiac: {
+        shortDescription: "Exports functions IaC code",
+        public: false,
+    },
     functionsrunapionly: {
         shortDescription: "Use Cloud Run API to list v2 functions",
         public: false,
     },
+    bypassfunctionsdeprecationcheck: {
+        shortDescription: "Bypass Functions check for old runtimes",
+        fullDescription: "Bypasses the local check for whether a functions runtime is " +
+            "decommissioned. This does not, by itself, allow you to deploy a function with a " +
+            "decommissioned runtime, as there are server-side checks as well.",
+        public: false,
+        default: false,
+    },
     emulatoruisnapshot: {
         shortDescription: "Load pre-release versions of the emulator UI",
     },
@@ -109,6 +121,11 @@ exports.ALL_EXPERIMENTS = experiments({
         default: false,
         public: false,
     },
+    abiu: {
+        shortDescription: "Enable App Hosting ABIU and runtime selection",
+        default: false,
+        public: false,
+    },
     dataconnect: {
         shortDescription: "Deprecated. Previosuly, enabled Data Connect related features.",
         fullDescription: "Deprecated. Previously, enabled Data Connect related features.",
@@ -150,6 +167,11 @@ exports.ALL_EXPERIMENTS = experiments({
         default: true,
         public: false,
     },
+    fdcrealtime: {
+        shortDescription: "Enable Firebase Data Connect realtime feature.",
+        default: false,
+        public: false,
+    },
 });
 function isValidExperiment(name) {
     return Object.keys(exports.ALL_EXPERIMENTS).includes(name);