firebase-tools 11.20.0 → 11.22.0

package/lib/emulator/functionsEmulator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionsEmulator = void 0;
+exports.FunctionsEmulator = exports.TCPConn = exports.IPCConn = void 0;
 const fs = require("fs");
 const path = require("path");
 const express = require("express");
@@ -8,6 +8,7 @@ const clc = require("colorette");
 const http = require("http");
 const jwt = require("jsonwebtoken");
 const cors = require("cors");
+const semver = require("semver");
 const url_1 = require("url");
 const events_1 = require("events");
 const logger_1 = require("../logger");
@@ -15,6 +16,7 @@ const track_1 = require("../track");
 const constants_1 = require("./constants");
 const types_1 = require("./types");
 const chokidar = require("chokidar");
+const portfinder = require("portfinder");
 const spawn = require("cross-spawn");
 const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
 const registry_1 = require("./registry");
@@ -33,9 +35,34 @@ const functionsEnv = require("../functions/env");
 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 EVENT_INVOKE = "functions:invoke";
 const EVENT_INVOKE_GA4 = "functions_invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
+class IPCConn {
+    constructor(socketPath) {
+        this.socketPath = socketPath;
+    }
+    httpReqOpts() {
+        return {
+            socketPath: this.socketPath,
+        };
+    }
+}
+exports.IPCConn = IPCConn;
+class TCPConn {
+    constructor(host, port) {
+        this.host = host;
+        this.port = port;
+    }
+    httpReqOpts() {
+        return {
+            host: this.host,
+            port: this.port,
+        };
+    }
+}
+exports.TCPConn = TCPConn;
 class FunctionsEmulator {
     constructor(args) {
         this.args = args;
@@ -168,7 +195,13 @@ class FunctionsEmulator {
         const record = this.getTriggerRecordByKey(this.getTriggerKey(trigger));
         const pool = this.workerPools[record.backend.codebase];
         if (!pool.readyForWork(trigger.id)) {
-            await this.startRuntime(record.backend, trigger);
+            try {
+                await this.startRuntime(record.backend, trigger);
+            }
+            catch (e) {
+                this.logger.logLabeled("ERROR", `Failed to start runtime for ${trigger.id}: ${e}`);
+                return;
+            }
         }
         const worker = pool.getIdleWorker(trigger.id);
         const reqBody = JSON.stringify(body);
@@ -177,20 +210,13 @@ class FunctionsEmulator {
             "Content-Length": `${reqBody.length}`,
         };
         return new Promise((resolve, reject) => {
-            const req = http.request({
-                path: `/`,
-                socketPath: worker.runtime.socketPath,
-                headers: headers,
-            }, resolve);
+            const req = http.request(Object.assign(Object.assign({}, worker.runtime.conn.httpReqOpts()), { path: `/`, headers: headers }), resolve);
             req.on("error", reject);
             req.write(reqBody);
             req.end();
         });
     }
     async start() {
-        for (const backend of this.args.emulatableBackends) {
-            backend.nodeBinary = this.getNodeBinary(backend);
-        }
         const credentialEnv = await this.getCredentialsEnvironment();
         for (const e of this.args.emulatableBackends) {
             e.env = Object.assign(Object.assign({}, credentialEnv), e.env);
@@ -219,6 +245,7 @@ class FunctionsEmulator {
                     /.+?[\\\/]node_modules[\\\/].+?/,
                     /(^|[\/\\])\../,
                     /.+\.log/,
+                    /.+?[\\\/]venv[\\\/].+?/,
                 ],
                 persistent: true,
             });
@@ -257,21 +284,22 @@ class FunctionsEmulator {
                 projectId: this.args.projectId,
                 projectDir: this.args.projectDir,
                 sourceDir: emulatableBackend.functionsDir,
+                runtime: emulatableBackend.runtime,
             };
-            if (emulatableBackend.nodeMajorVersion) {
-                runtimeDelegateContext.runtime = `nodejs${emulatableBackend.nodeMajorVersion}`;
-            }
             const runtimeDelegate = await runtimes.getRuntimeDelegate(runtimeDelegateContext);
             logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
             await runtimeDelegate.validate();
             logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
             await runtimeDelegate.build();
+            emulatableBackend.runtime = runtimeDelegate.runtime;
+            emulatableBackend.bin = runtimeDelegate.bin;
             const firebaseConfig = this.getFirebaseConfig();
             const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: firebaseConfig }), emulatableBackend.env);
             const userEnvOpt = {
                 functionsSource: emulatableBackend.functionsDir,
                 projectId: this.args.projectId,
                 projectAlias: this.args.projectAlias,
+                isEmulator: true,
             };
             const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
@@ -286,9 +314,7 @@ class FunctionsEmulator {
         }
     }
     async loadTriggers(emulatableBackend, force = false) {
-        if (!emulatableBackend.nodeBinary) {
-            throw new error_1.FirebaseError(`No node binary for ${emulatableBackend.functionsDir}. This should never happen.`);
-        }
+        var _a;
         let triggerDefinitions = [];
         try {
             triggerDefinitions = await this.discoverTriggers(emulatableBackend);
@@ -381,13 +407,23 @@ class FunctionsEmulator {
             }
         }
         if (this.args.debugPort) {
-            emulatableBackend.secretEnv = Object.values(triggerDefinitions.reduce((acc, curr) => {
-                for (const secret of curr.secretEnvironmentVariables || []) {
-                    acc[secret.key] = secret;
+            if (!((_a = emulatableBackend.bin) === null || _a === void 0 ? void 0 : _a.startsWith("node"))) {
+                this.logger.log("WARN", "--inspect-functions only supported for Node.js runtimes.");
+            }
+            else {
+                emulatableBackend.secretEnv = Object.values(triggerDefinitions.reduce((acc, curr) => {
+                    for (const secret of curr.secretEnvironmentVariables || []) {
+                        acc[secret.key] = secret;
+                    }
+                    return acc;
+                }, {}));
+                try {
+                    await this.startRuntime(emulatableBackend);
                 }
-                return acc;
-            }, {}));
-            await this.startRuntime(emulatableBackend);
+                catch (e) {
+                    this.logger.logLabeled("ERROR", `Failed to start functions in ${emulatableBackend.functionsDir}: ${e}`);
+                }
+            }
         }
     }
     addEventarcTrigger(projectId, key, eventTrigger) {
@@ -632,43 +668,6 @@ class FunctionsEmulator {
         this.triggers = {};
         triggers.forEach((def) => this.addTriggerRecord(def, { backend, ignored: false }));
     }
-    getNodeBinary(backend) {
-        const pkg = require(path.join(backend.functionsDir, "package.json"));
-        if ((!pkg.engines || !pkg.engines.node) && !backend.nodeMajorVersion) {
-            this.logger.log("WARN", `Your functions directory ${backend.functionsDir} does not specify a Node version.\n   ` +
-                "- Learn more at https://firebase.google.com/docs/functions/manage-functions#set_runtime_options");
-            return process.execPath;
-        }
-        const hostMajorVersion = process.versions.node.split(".")[0];
-        const requestedMajorVersion = backend.nodeMajorVersion
-            ? `${backend.nodeMajorVersion}`
-            : pkg.engines.node;
-        let localMajorVersion = "0";
-        const localNodePath = path.join(backend.functionsDir, "node_modules/.bin/node");
-        try {
-            const localNodeOutput = spawn.sync(localNodePath, ["--version"]).stdout.toString();
-            localMajorVersion = localNodeOutput.slice(1).split(".")[0];
-        }
-        catch (err) {
-        }
-        if (requestedMajorVersion === localMajorVersion) {
-            this.logger.logLabeled("SUCCESS", "functions", `Using node@${requestedMajorVersion} from local cache.`);
-            return localNodePath;
-        }
-        if (requestedMajorVersion === hostMajorVersion) {
-            this.logger.logLabeled("SUCCESS", "functions", `Using node@${requestedMajorVersion} from host.`);
-        }
-        else {
-            if (process.env.FIREPIT_VERSION) {
-                this.logger.log("WARN", `You've requested "node" version "${requestedMajorVersion}", but the standalone Firebase CLI comes with bundled Node "${hostMajorVersion}".`);
-                this.logger.log("INFO", `To use a different Node.js version, consider removing the standalone Firebase CLI and switching to "firebase-tools" on npm.`);
-            }
-            else {
-                this.logger.log("WARN", `Your requested "node" version "${requestedMajorVersion}" doesn't match your global version "${hostMajorVersion}". Using node@${hostMajorVersion} from host.`);
-            }
-        }
-        return process.execPath;
-    }
     getRuntimeConfig(backend) {
         const configPath = `${backend.functionsDir}/.runtimeconfig.json`;
         try {
@@ -791,13 +790,11 @@ class FunctionsEmulator {
         }
         return secretEnvs;
     }
-    async startRuntime(backend, trigger) {
-        var _a;
-        const emitter = new events_1.EventEmitter();
+    async startNode(backend, envs) {
         const args = [path.join(__dirname, "functionsEmulatorRuntime")];
         if (this.args.debugPort) {
-            if (process.env.FIREPIT_VERSION && process.execPath === backend.nodeBinary) {
-                this.logger.log("WARN", `To enable function inspection, please run "${process.execPath} is:npm i node@${backend.nodeMajorVersion} --save-dev" in your functions directory`);
+            if (process.env.FIREPIT_VERSION) {
+                this.logger.log("WARN", `To enable function inspection, please run "npm i node@${semver.coerce(backend.runtime || "18.0.0")} --save-dev" in your functions directory`);
             }
             else {
                 const { host } = this.getInfo();
@@ -810,20 +807,51 @@ class FunctionsEmulator {
                 "Cloud Functions for Firebase requires a node_modules folder to work correctly and is therefore incompatible with PnP. " +
                 "See https://yarnpkg.com/getting-started/migration#step-by-step for more information.");
         }
-        const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
-        const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
+        const bin = backend.bin;
+        if (!bin) {
+            throw new Error(`No binary associated with ${backend.functionsDir}. ` +
+                "Make sure function runtime is configured correctly in firebase.json.");
+        }
         const socketPath = (0, functionsEmulatorShared_1.getTemporarySocketPath)();
-        const childProcess = spawn(backend.nodeBinary, args, {
+        const childProcess = spawn(bin, args, {
             cwd: backend.functionsDir,
-            env: Object.assign(Object.assign(Object.assign(Object.assign({ node: backend.nodeBinary }, process.env), runtimeEnv), secretEnvs), { PORT: socketPath }),
+            env: Object.assign(Object.assign(Object.assign({ node: backend.bin }, process.env), envs), { PORT: socketPath }),
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
-        const runtime = {
+        return Promise.resolve({
+            process: childProcess,
+            events: new events_1.EventEmitter(),
+            cwd: backend.functionsDir,
+            conn: new IPCConn(socketPath),
+        });
+    }
+    async startPython(backend, envs) {
+        const args = ["functions-framework"];
+        if (this.args.debugPort) {
+            this.logger.log("WARN", "--inspect-functions not supported for Python functions. Ignored.");
+        }
+        const port = await portfinder.getPortPromise({
+            port: 8081 + (0, utils_1.randomInt)(0, 1000),
+        });
+        const childProcess = (0, python_1.runWithVirtualEnv)(args, backend.functionsDir, Object.assign(Object.assign(Object.assign({}, process.env), envs), { PYTHONUNBUFFERED: "1", DEBUG: "False", HOST: "127.0.0.1", PORT: port.toString() }));
+        return {
             process: childProcess,
-            events: emitter,
+            events: new events_1.EventEmitter(),
             cwd: backend.functionsDir,
-            socketPath,
+            conn: new TCPConn("127.0.0.1", port),
         };
+    }
+    async startRuntime(backend, trigger) {
+        var _a;
+        const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
+        const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
+        let runtime;
+        if (backend.runtime.startsWith("python")) {
+            runtime = await this.startPython(backend, Object.assign(Object.assign({}, runtimeEnv), secretEnvs));
+        }
+        else {
+            runtime = await this.startNode(backend, Object.assign(Object.assign({}, runtimeEnv), secretEnvs));
+        }
         const extensionLogInfo = {
             instanceId: backend.extensionInstanceId,
             ref: (_a = backend.extensionVersion) === null || _a === void 0 ? void 0 : _a.ref,
@@ -927,7 +955,14 @@ class FunctionsEmulator {
         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)) {
-            await this.startRuntime(record.backend, trigger);
+            try {
+                await this.startRuntime(record.backend, trigger);
+            }
+            catch (e) {
+                this.logger.logLabeled("ERROR", `Failed to handle request for function ${trigger.id}`);
+                this.logger.logLabeled("ERROR", `Failed to start functions in ${record.backend.functionsDir}: ${e}`);
+                return;
+            }
         }
         const debugBundle = this.args.debugPort
             ? {

package/lib/emulator/functionsRuntimeWorker.js

@@ -86,12 +86,7 @@ class RuntimeWorker {
             }
         };
         return new Promise((resolve) => {
-            const proxy = http.request({
-                method: req.method,
-                path: req.path,
-                headers: req.headers,
-                socketPath: this.runtime.socketPath,
-            }, (_resp) => {
+            const proxy = http.request(Object.assign(Object.assign({}, this.runtime.conn.httpReqOpts()), { method: req.method, path: req.path, headers: req.headers }), (_resp) => {
                 resp.writeHead(_resp.statusCode || 200, _resp.headers);
                 const piped = _resp.pipe(resp);
                 piped.on("finish", () => {
@@ -137,16 +132,11 @@ class RuntimeWorker {
     }
     isSocketReady() {
         return new Promise((resolve, reject) => {
-            const req = http
-                .request({
-                method: "GET",
-                path: "/__/health",
-                socketPath: this.runtime.socketPath,
-            }, () => {
+            const req = http.request(Object.assign(Object.assign({}, this.runtime.conn.httpReqOpts()), { method: "GET", path: "/__/health" }), () => {
                 this.readyForWork();
                 resolve();
-            })
-                .end();
+            });
+            req.end();
             req.on("error", (error) => {
                 reject(error);
             });

package/lib/emulator/storage/apis/firebase.js

@@ -229,6 +229,7 @@ function createFirebaseEndpoints(emulator) {
                     throw err;
                 }
                 res.header("X-Goog-Upload-Size-Received", upload.size.toString());
+                res.header("x-goog-upload-status", upload.status);
                 return res.sendStatus(200);
             }
             if (uploadCommand === "cancel") {

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

@@ -52,7 +52,7 @@ class DefaultStorageRulesManager {
                 this._logger.log("WARN", `${parsedIssue.description_.replace(/\.$/, "")} in ${parsedIssue.sourcePosition_.fileName_}:${parsedIssue.sourcePosition_.line_}`);
             }
             catch (_a) {
-                this._logger.log("WARN", issue);
+                this._logger.logLabeled("WARN", "storage", issue);
             }
         });
         return issues;

package/lib/emulator/storage/server.js

@@ -24,8 +24,8 @@ function createApp(defaultProjectId, emulator) {
         exposedHeaders: [
             "content-type",
             "x-firebase-storage-version",
+            "X-Goog-Upload-Size-Received",
             "x-goog-upload-url",
-            "x-goog-upload-status",
             "x-goog-upload-command",
             "x-gupload-uploadid",
             "x-goog-upload-header-content-length",

package/lib/emulator/storage/upload.js

@@ -11,9 +11,9 @@ var UploadType;
 })(UploadType = exports.UploadType || (exports.UploadType = {}));
 var UploadStatus;
 (function (UploadStatus) {
-    UploadStatus[UploadStatus["ACTIVE"] = 0] = "ACTIVE";
-    UploadStatus[UploadStatus["CANCELLED"] = 1] = "CANCELLED";
-    UploadStatus[UploadStatus["FINISHED"] = 2] = "FINISHED";
+    UploadStatus["ACTIVE"] = "active";
+    UploadStatus["CANCELLED"] = "cancelled";
+    UploadStatus["FINISHED"] = "final";
 })(UploadStatus = exports.UploadStatus || (exports.UploadStatus = {}));
 class UploadNotActiveError extends Error {
 }

package/lib/extensions/askUserForParam.js

@@ -13,6 +13,7 @@ const logger_1 = require("../logger");
 const prompt_1 = require("../prompt");
 const utils = require("../utils");
 const projectUtils_1 = require("../projectUtils");
+const functional_1 = require("../functional");
 var SecretLocation;
 (function (SecretLocation) {
     SecretLocation[SecretLocation["CLOUD"] = 1] = "CLOUD";
@@ -67,8 +68,9 @@ async function ask(args) {
     }
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, "answer the questions below to configure your extension:");
     const substituted = (0, extensionsHelper_1.substituteParams)(args.paramSpecs, args.firebaseProjectParams);
+    const [advancedParams, standardParams] = (0, functional_1.partition)(substituted, (p) => { var _a; return (_a = p.advanced) !== null && _a !== void 0 ? _a : false; });
     const result = {};
-    const promises = substituted.map((paramSpec) => {
+    const promises = standardParams.map((paramSpec) => {
         return async () => {
             result[paramSpec.param] = await askForParam({
                 projectId: args.projectId,
@@ -78,6 +80,35 @@ async function ask(args) {
             });
         };
     });
+    if (advancedParams.length) {
+        promises.push(async () => {
+            const shouldPrompt = await (0, prompt_1.promptOnce)({
+                type: "confirm",
+                message: "Do you want to configure any advanced parameters for this instance?",
+                default: false,
+            });
+            if (shouldPrompt) {
+                const advancedPromises = advancedParams.map((paramSpec) => {
+                    return async () => {
+                        result[paramSpec.param] = await askForParam({
+                            projectId: args.projectId,
+                            instanceId: args.instanceId,
+                            paramSpec: paramSpec,
+                            reconfiguring: args.reconfiguring,
+                        });
+                    };
+                });
+                await advancedPromises.reduce((prev, cur) => prev.then(cur), Promise.resolve());
+            }
+            else {
+                for (const paramSpec of advancedParams) {
+                    if (paramSpec.required && paramSpec.default) {
+                        result[paramSpec.param] = { baseValue: paramSpec.default };
+                    }
+                }
+            }
+        });
+    }
     await promises.reduce((prev, cur) => prev.then(cur), Promise.resolve());
     logger_1.logger.info();
     return result;

package/lib/extensions/emulator/optionsHelper.js

@@ -32,7 +32,7 @@ async function buildOptions(options) {
     options.extDevEnv = params;
     const functionEmuTriggerDefs = functionResources.map((r) => triggerHelper.functionResourceToEmulatedTriggerDefintion(r));
     options.extDevTriggers = functionEmuTriggerDefs;
-    options.extDevNodeVersion = specHelper.getNodeVersion(functionResources);
+    options.extDevRuntime = specHelper.getRuntime(functionResources);
     return options;
 }
 exports.buildOptions = buildOptions;
@@ -45,12 +45,12 @@ async function getExtensionFunctionInfo(instance, paramValues) {
         trigger.name = `ext-${instance.instanceId}-${trigger.name}`;
         return trigger;
     });
-    const nodeMajorVersion = specHelper.getNodeVersion(functionResources);
+    const runtime = specHelper.getRuntime(functionResources);
     const nonSecretEnv = getNonSecretEnv(spec.params, paramValues);
     const secretEnvVariables = getSecretEnvVars(spec.params, paramValues);
     return {
         extensionTriggers,
-        nodeMajorVersion,
+        runtime,
         nonSecretEnv,
         secretEnvVariables,
     };

package/lib/extensions/emulator/specHelper.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNodeVersion = exports.getFunctionProperties = exports.getFunctionResourcesWithParamSubstitution = exports.readFileFromDirectory = exports.readPostinstall = exports.readExtensionYaml = void 0;
+exports.getRuntime = exports.DEFAULT_RUNTIME = exports.getFunctionProperties = exports.getFunctionResourcesWithParamSubstitution = exports.readFileFromDirectory = exports.readPostinstall = exports.readExtensionYaml = void 0;
 const yaml = require("js-yaml");
 const path = require("path");
 const fs = require("fs-extra");
 const error_1 = require("../../error");
 const extensionsHelper_1 = require("../extensionsHelper");
 const utils_1 = require("../utils");
-const functionsEmulatorUtils_1 = require("../../emulator/functionsEmulatorUtils");
 const SPEC_FILE = "extension.yaml";
 const POSTINSTALL_FILE = "POSTINSTALL.md";
 const validFunctionTypes = [
@@ -67,24 +66,26 @@ function getFunctionProperties(resources) {
     return resources.map((r) => r.properties);
 }
 exports.getFunctionProperties = getFunctionProperties;
-function getNodeVersion(resources) {
+exports.DEFAULT_RUNTIME = "nodejs14";
+function getRuntime(resources) {
+    if (resources.length === 0) {
+        return exports.DEFAULT_RUNTIME;
+    }
     const invalidRuntimes = [];
-    const versions = resources.map((r) => {
-        if ((0, utils_1.getResourceRuntime)(r)) {
-            const runtimeName = (0, utils_1.getResourceRuntime)(r);
-            const runtime = (0, functionsEmulatorUtils_1.parseRuntimeVersion)(runtimeName);
-            if (!runtime) {
-                invalidRuntimes.push(runtimeName);
-            }
-            else {
-                return runtime;
-            }
+    const runtimes = resources.map((r) => {
+        const runtime = (0, utils_1.getResourceRuntime)(r);
+        if (!runtime) {
+            return exports.DEFAULT_RUNTIME;
+        }
+        if (!/^(nodejs)?([0-9]+)/.test(runtime)) {
+            invalidRuntimes.push(runtime);
+            return exports.DEFAULT_RUNTIME;
         }
-        return 14;
+        return runtime;
     });
     if (invalidRuntimes.length) {
         throw new error_1.FirebaseError(`The following runtimes are not supported by the Emulator Suite: ${invalidRuntimes.join(", ")}. \n Only Node runtimes are supported.`);
     }
-    return Math.max(...versions);
+    return runtimes.sort()[runtimes.length - 1];
 }
-exports.getNodeVersion = getNodeVersion;
+exports.getRuntime = getRuntime;

package/lib/extensions/extensionsApi.js

@@ -34,9 +34,10 @@ async function createInstanceHelper(projectId, instanceId, config, validateOnly
     return pollRes;
 }
 async function createInstance(args) {
-    var _a, _b;
+    var _a, _b, _c;
     const config = {
         params: args.params,
+        systemParams: (_a = args.systemParams) !== null && _a !== void 0 ? _a : {},
         allowedEventTypes: args.allowedEventTypes,
         eventarcChannel: args.eventarcChannel,
     };
@@ -44,12 +45,12 @@ async function createInstance(args) {
         throw new error_1.FirebaseError("ExtensionSource and ExtensionVersion both provided, but only one should be.");
     }
     else if (args.extensionSource) {
-        config.source = { name: (_a = args.extensionSource) === null || _a === void 0 ? void 0 : _a.name };
+        config.source = { name: (_b = args.extensionSource) === null || _b === void 0 ? void 0 : _b.name };
     }
     else if (args.extensionVersionRef) {
         const ref = refs.parse(args.extensionVersionRef);
         config.extensionRef = refs.toExtensionRef(ref);
-        config.extensionVersion = (_b = ref.version) !== null && _b !== void 0 ? _b : "";
+        config.extensionVersion = (_c = ref.version) !== null && _c !== void 0 ? _c : "";
     }
     else {
         throw new error_1.FirebaseError("No ExtensionVersion or ExtensionSource provided but one is required.");
@@ -128,6 +129,10 @@ async function configureInstance(args) {
         reqBody.data.config.eventarcChannel = args.eventarcChannel;
     }
     reqBody.updateMask += ",config.allowed_event_types,config.eventarc_channel";
+    if (args.systemParams) {
+        reqBody.data.config.systemParams = args.systemParams;
+        reqBody.updateMask += ",config.system_params";
+    }
     return patchInstance(reqBody);
 }
 exports.configureInstance = configureInstance;
@@ -143,6 +148,10 @@ async function updateInstance(args) {
         body.config.params = args.params;
         updateMask += ",config.params";
     }
+    if (args.systemParams) {
+        body.config.systemParams = args.systemParams;
+        updateMask += ",config.system_params";
+    }
     if (args.canEmitEvents) {
         if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
             throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);
@@ -174,6 +183,10 @@ async function updateInstanceFromRegistry(args) {
         body.config.params = args.params;
         updateMask += ",config.params";
     }
+    if (args.systemParams) {
+        body.config.systemParams = args.systemParams;
+        updateMask += ",config.system_params";
+    }
     if (args.canEmitEvents) {
         if (args.allowedEventTypes === undefined || args.eventarcChannel === undefined) {
             throw new error_1.FirebaseError(`This instance is configured to emit events, but either allowed event types or eventarc channel is undefined.`);

package/lib/extensions/paramHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readEnvFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = exports.setNewDefaults = exports.buildBindingOptionsWithBaseValue = exports.getBaseParamBindings = void 0;
+exports.isSystemParam = exports.readEnvFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = exports.setNewDefaults = exports.buildBindingOptionsWithBaseValue = exports.getBaseParamBindings = void 0;
 const path = require("path");
 const clc = require("colorette");
 const fs = require("fs-extra");
@@ -172,3 +172,8 @@ function readEnvFile(envPath) {
     return result.envs;
 }
 exports.readEnvFile = readEnvFile;
+function isSystemParam(paramName) {
+    const regex = /^firebaseextensions\.[a-zA-Z0-9\.]*\//;
+    return regex.test(paramName);
+}
+exports.isSystemParam = isSystemParam;

package/lib/firestore/checkDatabaseType.js

@@ -6,9 +6,9 @@ const apiv2_1 = require("../apiv2");
 const logger_1 = require("../logger");
 async function checkDatabaseType(projectId) {
     try {
-        const client = new apiv2_1.Client({ urlPrefix: api_1.appengineOrigin, apiVersion: "v1" });
-        const resp = await client.get(`/apps/${projectId}`);
-        return resp.body.databaseType;
+        const client = new apiv2_1.Client({ urlPrefix: api_1.firestoreOrigin, apiVersion: "v1" });
+        const resp = await client.get(`/projects/${projectId}/databases/(default)`);
+        return resp.body.type;
     }
     catch (err) {
         logger_1.logger.debug("error getting database type", err);

package/lib/frameworks/index.js

@@ -120,8 +120,8 @@ function findDependency(name, options = {}) {
 }
 exports.findDependency = findDependency;
 async function prepareFrameworks(targetNames, context, options, emulators = []) {
-    var _a;
-    var _b, _c, _d, _e;
+    var _a, _b;
+    var _c, _d, _e, _f;
     const nodeVersion = process.version;
     if (!semver.satisfies(nodeVersion, ">=16.0.0")) {
         throw new error_1.FirebaseError(`The frameworks awareness feature requires Node.JS >= 16 and npm >= 8 in order to work correctly, due to some of the downstream dependencies. Please upgrade your version of Node.JS, reinstall firebase-tools, and give it another go.`);
@@ -133,7 +133,7 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
         try {
             await (0, requireHostingSite_1.requireHostingSite)(options);
         }
-        catch (_f) {
+        catch (_g) {
             options.site = project;
         }
     }
@@ -243,10 +243,11 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
             }
         }
         else {
-            const { wantsBackend = false, rewrites = [], redirects = [], headers = [], } = (await build(getProjectPath())) || {};
+            const { wantsBackend = false, rewrites = [], redirects = [], headers = [], trailingSlash, } = (await build(getProjectPath())) || {};
             config.rewrites.push(...rewrites);
             config.redirects.push(...redirects);
             config.headers.push(...headers);
+            (_b = config.trailingSlash) !== null && _b !== void 0 ? _b : (config.trailingSlash = trailingSlash);
             if (await (0, fs_extra_1.pathExists)(hostingDist))
                 await (0, promises_1.rm)(hostingDist, { recursive: true });
             await (0, fs_extra_1.mkdirp)(hostingDist);
@@ -319,11 +320,11 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
             packageJson.main = "server.js";
             delete packageJson.devDependencies;
             packageJson.dependencies || (packageJson.dependencies = {});
-            (_b = packageJson.dependencies)["firebase-frameworks"] || (_b["firebase-frameworks"] = exports.FIREBASE_FRAMEWORKS_VERSION);
-            (_c = packageJson.dependencies)["firebase-functions"] || (_c["firebase-functions"] = exports.FIREBASE_FUNCTIONS_VERSION);
-            (_d = packageJson.dependencies)["firebase-admin"] || (_d["firebase-admin"] = exports.FIREBASE_ADMIN_VERSION);
+            (_c = packageJson.dependencies)["firebase-frameworks"] || (_c["firebase-frameworks"] = exports.FIREBASE_FRAMEWORKS_VERSION);
+            (_d = packageJson.dependencies)["firebase-functions"] || (_d["firebase-functions"] = exports.FIREBASE_FUNCTIONS_VERSION);
+            (_e = packageJson.dependencies)["firebase-admin"] || (_e["firebase-admin"] = exports.FIREBASE_ADMIN_VERSION);
             packageJson.engines || (packageJson.engines = {});
-            (_e = packageJson.engines).node || (_e.node = exports.NODE_VERSION);
+            (_f = packageJson.engines).node || (_f.node = exports.NODE_VERSION);
             await (0, promises_1.writeFile)((0, path_1.join)(functionsDist, "package.json"), JSON.stringify(packageJson, null, 2));
             await (0, promises_1.writeFile)((0, path_1.join)(functionsDist, ".env"), `__FIREBASE_FRAMEWORKS_ENTRY__=${frameworksEntry}
 ${firebaseDefaults ? `__FIREBASE_DEFAULTS__=${JSON.stringify(firebaseDefaults)}\n` : ""}`);