firebase-tools 11.29.1 → 12.0.0

package/lib/deploy/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deploy = void 0;
+const clc = require("colorette");
 const logger_1 = require("../logger");
 const api_1 = require("../api");
 const colorette_1 = require("colorette");
@@ -19,8 +20,10 @@ const StorageTarget = require("./storage");
 const RemoteConfigTarget = require("./remoteconfig");
 const ExtensionsTarget = require("./extensions");
 const frameworks_1 = require("../frameworks");
-const requirePermissions_1 = require("../requirePermissions");
+const prepare_1 = require("./hosting/prepare");
+const github_1 = require("../init/features/hosting/github");
 const deploy_1 = require("../commands/deploy");
+const requirePermissions_1 = require("../requirePermissions");
 const TARGETS = {
     hosting: HostingTarget,
     database: DatabaseTarget,
@@ -48,17 +51,30 @@ const deploy = async function (targetNames, options, customContext = {}) {
     if (targetNames.includes("hosting")) {
         const config = options.config.get("hosting");
         if (Array.isArray(config) ? config.some((it) => it.source) : config.source) {
-            experiments.assertEnabled("webframeworks", "deploy a web framework to hosting");
-            const usedToTargetFunctions = targetNames.includes("functions");
+            experiments.assertEnabled("webframeworks", "deploy a web framework from source");
             await (0, frameworks_1.prepareFrameworks)(targetNames, context, options);
-            const nowTargetsFunctions = targetNames.includes("functions");
-            if (nowTargetsFunctions && !usedToTargetFunctions) {
-                if (context.hostingChannel && !experiments.isEnabled("pintags")) {
-                    throw new error_1.FirebaseError("Web frameworks with dynamic content do not yet support deploying to preview channels");
+        }
+    }
+    if (targetNames.includes("hosting") && (0, prepare_1.hasPinnedFunctions)(options)) {
+        experiments.assertEnabled("pintags", "deploy a tagged function as a hosting rewrite");
+        if (!targetNames.includes("functions")) {
+            targetNames.unshift("functions");
+            try {
+                await (0, requirePermissions_1.requirePermissions)(options, deploy_1.TARGET_PERMISSIONS["functions"]);
+            }
+            catch (e) {
+                if ((0, github_1.isRunningInGithubAction)()) {
+                    throw new error_1.FirebaseError("It looks like you are deploying a Hosting site along with Cloud Functions " +
+                        "using a GitHub action version that did not include Cloud Functions " +
+                        "permissions. Please reinstall the GitHub action with" +
+                        clc.bold("firebase init hosting:github"), { original: e });
+                }
+                else {
+                    throw e;
                 }
-                await (0, requirePermissions_1.requirePermissions)(deploy_1.TARGET_PERMISSIONS["functions"]);
             }
         }
+        await (0, prepare_1.addPinnedFunctionsToOnlyString)(context, options);
     }
     for (const targetName of targetNames) {
         const target = TARGETS[targetName];

package/lib/emulator/adminSdkConfig.js

@@ -37,6 +37,14 @@ async function getProjectAdminSdkConfig(projectId) {
         apiVersion: "v1beta1",
         urlPrefix: api_1.firebaseApiOrigin,
     });
+    if (projectId.startsWith("demo-")) {
+        logger_1.logger.debug(`Detected demo- project: ${projectId}. Using default adminSdkConfig instead of calling firebase API.`);
+        return {
+            projectId,
+            databaseURL: `${projectId}-default-rtdb.firebaseio.com`,
+            storageBucket: `${projectId}.appspot.com`,
+        };
+    }
     try {
         const res = await apiClient.get(`projects/${projectId}/adminSdkConfig`);
         return res.body;

package/lib/emulator/controller.js

@@ -282,15 +282,13 @@ async function startAll(options, showUI = true) {
     if (Array.isArray(hostingConfig) ? hostingConfig.some((it) => it.source) : hostingConfig === null || hostingConfig === void 0 ? void 0 : hostingConfig.source) {
         experiments.assertEnabled("webframeworks", "emulate a web framework");
         const emulators = [];
-        if (experiments.isEnabled("webframeworks")) {
-            for (const e of types_1.ALL_SERVICE_EMULATORS) {
-                if (listenForEmulator[e]) {
-                    emulators.push({
-                        name: e,
-                        host: utils.connectableHostname(listenForEmulator[e][0].address),
-                        port: listenForEmulator[e][0].port,
-                    });
-                }
+        for (const e of types_1.ALL_SERVICE_EMULATORS) {
+            if (listenForEmulator[e]) {
+                emulators.push({
+                    name: e,
+                    host: utils.connectableHostname(listenForEmulator[e][0].address),
+                    port: listenForEmulator[e][0].port,
+                });
             }
         }
         await (0, frameworks_1.prepareFrameworks)(targets, options, options, emulators);

package/lib/emulator/download.js

@@ -5,9 +5,9 @@ const crypto = require("crypto");
 const fs = require("fs-extra");
 const path = require("path");
 const tmp = require("tmp");
-const unzipper = require("unzipper");
 const emulatorLogger_1 = require("./emulatorLogger");
 const error_1 = require("../error");
+const unzip_1 = require("../unzip");
 const downloadableEmulators = require("./downloadableEmulators");
 const downloadUtils = require("../downloadUtils");
 tmp.setGracefulCleanup();
@@ -25,9 +25,8 @@ async function downloadEmulator(name) {
     }
     fs.copySync(tmpfile, emulator.downloadPath);
     if (emulator.unzipDir) {
-        await unzip(emulator.downloadPath, emulator.unzipDir);
+        await (0, unzip_1.unzip)(emulator.downloadPath, emulator.unzipDir);
     }
-    await new Promise((f) => setTimeout(f, 2000));
     const executablePath = emulator.binaryPath || emulator.downloadPath;
     fs.chmodSync(executablePath, 0o755);
     removeOldFiles(name, emulator);
@@ -44,20 +43,12 @@ async function downloadExtensionVersion(extensionVersionRef, sourceDownloadUri,
     }
     emulatorLogger.logLabeled("BULLET", "extensions", `downloading ${sourceDownloadUri}...`);
     const sourceCodeZip = await downloadUtils.downloadToTmp(sourceDownloadUri);
-    await unzip(sourceCodeZip, targetDir);
+    await (0, unzip_1.unzip)(sourceCodeZip, targetDir);
     fs.chmodSync(targetDir, 0o755);
     emulatorLogger.logLabeled("BULLET", "extensions", `Downloaded to ${targetDir}...`);
     await new Promise((resolve) => setTimeout(resolve, 1000));
 }
 exports.downloadExtensionVersion = downloadExtensionVersion;
-function unzip(zipPath, unzipDir) {
-    return new Promise((resolve, reject) => {
-        fs.createReadStream(zipPath)
-            .pipe(unzipper.Extract({ path: unzipDir }))
-            .on("error", reject)
-            .on("close", resolve);
-    });
-}
 function removeOldFiles(name, emulator, removeAllVersions = false) {
     const currentLocalPath = emulator.downloadPath;
     const currentUnzipPath = emulator.unzipDir;

package/lib/emulator/downloadableEmulators.js

@@ -23,9 +23,9 @@ const EMULATOR_UPDATE_DETAILS = {
         expectedChecksum: "311609538bd65666eb724ef47c2e6466",
     },
     firestore: {
-        version: "1.17.3",
-        expectedSize: 64970588,
-        expectedChecksum: "75beb285dc404176b974fec9e3032712",
+        version: "1.17.4",
+        expectedSize: 64969580,
+        expectedChecksum: "9d580b58e55e57b0cdc3ca8888098d43",
     },
     storage: {
         version: "1.1.3",
@@ -35,9 +35,9 @@ const EMULATOR_UPDATE_DETAILS = {
     ui: experiments.isEnabled("emulatoruisnapshot")
         ? { version: "SNAPSHOT", expectedSize: -1, expectedChecksum: "" }
         : {
-            version: "1.11.5",
+            version: "1.11.6",
             expectedSize: 3063444,
-            expectedChecksum: "4045fef65cf71fb9d83b01fb8b160141",
+            expectedChecksum: "14b971f4ed4909f348e647db7114d62b",
         },
     pubsub: {
         version: "0.7.1",

package/lib/emulator/functionsEmulator.js

@@ -367,7 +367,7 @@ class FunctionsEmulator {
                 const signature = (0, functionsEmulatorShared_1.getSignatureType)(definition);
                 switch (service) {
                     case constants_1.Constants.SERVICE_FIRESTORE:
-                        added = await this.addFirestoreTrigger(this.args.projectId, key, definition.eventTrigger);
+                        added = await this.addFirestoreTrigger(this.args.projectId, key, definition.eventTrigger, signature);
                         break;
                     case constants_1.Constants.SERVICE_REALTIME_DATABASE:
                         added = await this.addRealtimeDatabaseTrigger(this.args.projectId, definition.id, key, definition.eventTrigger, signature, definition.region);
@@ -531,17 +531,60 @@ class FunctionsEmulator {
         }
         return true;
     }
-    async addFirestoreTrigger(projectId, key, eventTrigger) {
-        if (!registry_1.EmulatorRegistry.isRunning(types_1.Emulators.FIRESTORE)) {
-            return Promise.resolve(false);
-        }
+    getV1FirestoreAttributes(projectId, key, eventTrigger) {
         const bundle = JSON.stringify({
             eventTrigger: Object.assign(Object.assign({}, eventTrigger), { service: "firestore.googleapis.com" }),
         });
+        const path = `/emulator/v1/projects/${projectId}/triggers/${key}`;
+        return { bundle, path };
+    }
+    getV2FirestoreAttributes(projectId, key, eventTrigger) {
+        var _a, _b, _c, _d, _e, _f;
+        logger_1.logger.debug("Found a v2 firestore trigger.");
+        const database = (_a = eventTrigger.eventFilters) === null || _a === void 0 ? void 0 : _a.database;
+        if (!database) {
+            throw new error_1.FirebaseError("A database must be supplied.");
+        }
+        const namespace = (_b = eventTrigger.eventFilters) === null || _b === void 0 ? void 0 : _b.namespace;
+        if (!namespace) {
+            throw new error_1.FirebaseError("A namespace must be supplied.");
+        }
+        let doc;
+        let match;
+        if ((_c = eventTrigger.eventFilters) === null || _c === void 0 ? void 0 : _c.document) {
+            doc = (_d = eventTrigger.eventFilters) === null || _d === void 0 ? void 0 : _d.document;
+            match = "EXACT";
+        }
+        if ((_e = eventTrigger.eventFilterPathPatterns) === null || _e === void 0 ? void 0 : _e.document) {
+            doc = (_f = eventTrigger.eventFilterPathPatterns) === null || _f === void 0 ? void 0 : _f.document;
+            match = "PATH_PATTERN";
+        }
+        if (!doc) {
+            throw new error_1.FirebaseError("A document must be supplied.");
+        }
+        const bundle = JSON.stringify({
+            eventType: eventTrigger.eventType,
+            database,
+            namespace,
+            document: {
+                value: doc,
+                matchType: match,
+            },
+        });
+        const path = `/emulator/v1/projects/${projectId}/eventarcTrigger?eventarcTriggerId=${key}`;
+        return { bundle, path };
+    }
+    async addFirestoreTrigger(projectId, key, eventTrigger, signature) {
+        if (!registry_1.EmulatorRegistry.isRunning(types_1.Emulators.FIRESTORE)) {
+            return Promise.resolve(false);
+        }
+        const { bundle, path } = signature === "cloudevent"
+            ? this.getV2FirestoreAttributes(projectId, key, eventTrigger)
+            : this.getV1FirestoreAttributes(projectId, key, eventTrigger);
         logger_1.logger.debug(`addFirestoreTrigger`, JSON.stringify(bundle));
         const client = registry_1.EmulatorRegistry.client(types_1.Emulators.FIRESTORE);
         try {
-            await client.put(`/emulator/v1/projects/${projectId}/triggers/${key}`, bundle);
+            signature === "cloudevent" ? await client.post(path, bundle) : await client.put(path, bundle);
         }
         catch (err) {
             this.logger.log("WARN", "Error adding firestore function: " + err);
@@ -915,6 +958,7 @@ class FunctionsEmulator {
         }
     }
     async handleHttpsTrigger(req, res) {
+        var _a;
         const method = req.method;
         let triggerId = req.params.trigger_name;
         if (req.params.region) {
@@ -933,7 +977,13 @@ class FunctionsEmulator {
         }
         const trigger = record.def;
         logger_1.logger.debug(`Accepted request ${method} ${req.url} --> ${triggerId}`);
-        const reqBody = req.rawBody;
+        let reqBody = req.rawBody;
+        if ((0, functionsEmulatorShared_1.getSignatureType)(trigger) === "cloudevent") {
+            if ((_a = req.headers["content-type"]) === null || _a === void 0 ? void 0 : _a.includes("application/protobuf")) {
+                reqBody = Uint8Array.from(atob(reqBody.toString()), (c) => c.charCodeAt(0));
+                req.headers["content-length"] = reqBody.length.toString();
+            }
+        }
         const isCallable = trigger.labels && trigger.labels["deployment-callable"] === "true";
         const authHeader = req.header("Authorization");
         if (authHeader && isCallable && trigger.platform !== "gcfv2") {

package/lib/emulator/functionsEmulatorRuntime.js

@@ -677,12 +677,15 @@ async function main() {
             switch (FUNCTION_SIGNATURE) {
                 case "event":
                 case "cloudevent":
+                    let reqBody;
                     const rawBody = req.rawBody;
-                    let reqBody = JSON.parse(rawBody.toString());
                     if (types_2.EventUtils.isBinaryCloudEvent(req)) {
                         reqBody = types_2.EventUtils.extractBinaryCloudEventContext(req);
                         reqBody.data = req.body;
                     }
+                    else {
+                        reqBody = JSON.parse(rawBody.toString());
+                    }
                     await processBackground(trigger, reqBody, FUNCTION_SIGNATURE);
                     res.send({ status: "acknowledged" });
                     break;

package/lib/emulator/functionsEmulatorShared.js

@@ -19,6 +19,7 @@ const V2_EVENTS = [
     events.v2.PUBSUB_PUBLISH_EVENT,
     ...events.v2.STORAGE_EVENTS,
     ...events.v2.DATABASE_EVENTS,
+    ...events.v2.FIRESTORE_EVENTS,
 ];
 exports.EVENTARC_SOURCE_ENV = "EVENTARC_CLOUD_EVENT_SOURCE";
 class HttpConstants {

package/lib/emulator/functionsRuntimeWorker.js

@@ -110,11 +110,19 @@ class RuntimeWorker {
             }
             const proxy = http.request(reqOpts, (_resp) => {
                 resp.writeHead(_resp.statusCode || 200, _resp.headers);
+                let finished = false;
+                const finishReq = (event) => {
+                    this.logger.log("DEBUG", `Finishing up request with event=${event}`);
+                    if (!finished) {
+                        finished = true;
+                        onFinish();
+                        resolve();
+                    }
+                };
+                _resp.on("pause", () => finishReq("pause"));
+                _resp.on("close", () => finishReq("close"));
                 const piped = _resp.pipe(resp);
-                piped.on("finish", () => {
-                    onFinish();
-                    resolve();
-                });
+                piped.on("finish", () => finishReq("finish"));
             });
             proxy.on("timeout", () => {
                 this.logger.log("ERROR", `Your function timed out after ~${this.timeoutSeconds}s. To configure this timeout, see

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

@@ -12,12 +12,11 @@ function getSourceFile(rules, options) {
 }
 function getStorageRulesConfig(projectId, options) {
     const storageConfig = options.config.data.storage;
+    const storageLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
     if (!storageConfig) {
         if (constants_1.Constants.isDemoProject(projectId)) {
-            const storageLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.STORAGE);
             storageLogger.logLabeled("BULLET", "storage", `Detected demo project ID "${projectId}", using a default (open) rules configuration.`);
-            const path = __dirname + "/../../../../templates/emulators/default_storage.rules";
-            return { name: path, content: (0, fsutils_1.readFile)(path) };
+            return defaultStorageRules();
         }
         throw new error_1.FirebaseError("Cannot start the Storage emulator without rules file specified in firebase.json: run 'firebase init' and set up your Storage configuration");
     }
@@ -33,11 +32,22 @@ function getStorageRulesConfig(projectId, options) {
         if (!targetConfig.target) {
             throw new error_1.FirebaseError("Must supply 'target' in Storage configuration");
         }
-        rc.requireTarget(projectId, "storage", targetConfig.target);
-        rc.target(projectId, "storage", targetConfig.target).forEach((resource) => {
-            results.push({ resource, rules: getSourceFile(targetConfig.rules, options) });
-        });
+        const targets = rc.target(projectId, "storage", targetConfig.target);
+        if (targets.length === 0) {
+            if (constants_1.Constants.isDemoProject(projectId)) {
+                storageLogger.logLabeled("BULLET", "storage", `Detected demo project ID "${projectId}", using a default (open) rules configuration. Storage targets in firebase.json will be ignored.`);
+                return defaultStorageRules();
+            }
+            rc.requireTarget(projectId, "storage", targetConfig.target);
+        }
+        results.push(...rc.target(projectId, "storage", targetConfig.target).map((resource) => {
+            return { resource, rules: getSourceFile(targetConfig.rules, options) };
+        }));
     }
     return results;
 }
 exports.getStorageRulesConfig = getStorageRulesConfig;
+function defaultStorageRules() {
+    const path = __dirname + "/../../../../templates/emulators/default_storage.rules";
+    return { name: path, content: (0, fsutils_1.readFile)(path) };
+}

package/lib/experiments.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flushToDisk = exports.assertEnabled = exports.enableExperimentsFromCliEnvVariable = exports.setEnabled = exports.isEnabled = exports.experimentNameAutocorrect = exports.isValidExperiment = exports.ALL_EXPERIMENTS = void 0;
 const colorette_1 = require("colorette");
 const leven = require("leven");
+const path_1 = require("path");
 const configstore_1 = require("./configstore");
 const error_1 = require("./error");
+const github_1 = require("./init/features/hosting/github");
 function experiments(exp) {
     return Object.freeze(exp);
 }
@@ -18,13 +20,6 @@ exports.ALL_EXPERIMENTS = experiments({
     rtdbmanagement: {
         shortDescription: "Use new endpoint to administer realtime database instances",
     },
-    ext: {
-        shortDescription: `Enables the ${(0, colorette_1.bold)("ext:sources:create")} command`,
-    },
-    extdev: {
-        shortDescription: `Enables the ${(0, colorette_1.bold)("ext:dev")} family of commands`,
-        docsUri: "https://firebase.google.com/docs/extensions/alpha/overview-build-extensions",
-    },
     pythonfunctions: {
         shortDescription: "Python support for Cloud Functions for Firebase",
         fullDescription: "Adds the ability to initializea and deploy Cloud " +
@@ -65,6 +60,8 @@ exports.ALL_EXPERIMENTS = experiments({
             "exist per region. firebase-tools aggressively garbage collects tags it creates " +
             "if any service exceeds 500 tags, but it is theoretically possible that a project " +
             "exceeds the region-wide limit of tags and an old site version fails",
+        public: true,
+        default: true,
     },
     crossservicerules: {
         shortDescription: "Allow Firebase Rules to reference resources in other services",
@@ -123,8 +120,25 @@ function enableExperimentsFromCliEnvVariable() {
 }
 exports.enableExperimentsFromCliEnvVariable = enableExperimentsFromCliEnvVariable;
 function assertEnabled(name, task) {
+    var _a;
     if (!isEnabled(name)) {
-        throw new error_1.FirebaseError(`Cannot ${task} because the experiment ${(0, colorette_1.bold)(name)} is not enabled. To enable ${(0, colorette_1.bold)(name)} run ${(0, colorette_1.bold)(`firebase experiments:enable ${name}`)}`);
+        const prefix = `Cannot ${task} because the experiment ${(0, colorette_1.bold)(name)} is not enabled.`;
+        if ((0, github_1.isRunningInGithubAction)()) {
+            const path = (_a = process.env.GITHUB_WORKFLOW_REF) === null || _a === void 0 ? void 0 : _a.split("@")[0];
+            const filename = path ? `.github/workflows/${(0, path_1.basename)(path)}` : "your action's yml";
+            const newValue = [process.env.FIREBASE_CLI_EXPERIMENTS, name].filter((it) => !!it).join(",");
+            throw new error_1.FirebaseError(`${prefix} To enable add a ${(0, colorette_1.bold)("FIREBASE_CLI_EXPERIMENTS")} environment variable to ${filename}, like so: ${(0, colorette_1.italic)(`
+
+- uses: FirebaseExtended/action-hosting-deploy@v0
+  with:
+    ...
+  env:
+    FIREBASE_CLI_EXPERIMENTS: ${newValue}
+`)}`);
+        }
+        else {
+            throw new error_1.FirebaseError(`${prefix} To enable ${(0, colorette_1.bold)(name)} run ${(0, colorette_1.bold)(`firebase experiments:enable ${name}`)}`);
+        }
     }
 }
 exports.assertEnabled = assertEnabled;