firebase-tools 10.2.1 → 10.3.1

package/lib/emulator/controller.js

@@ -33,10 +33,17 @@ const prompt_1 = require("../prompt");
 const commandUtils_1 = require("./commandUtils");
 const fsutils_1 = require("../fsutils");
 const storage_1 = require("./storage");
+const config_1 = require("./storage/rules/config");
 const getDefaultDatabaseInstance_1 = require("../getDefaultDatabaseInstance");
 const auth_2 = require("../auth");
+const extensionsEmulator_1 = require("./extensionsEmulator");
+const previews_1 = require("../previews");
+const START_LOGGING_EMULATOR = utils.envOverride("START_LOGGING_EMULATOR", "false", (val) => val === "true");
 async function getAndCheckAddress(emulator, options) {
     var _a, _b, _c, _d;
+    if (emulator === types_1.Emulators.EXTENSIONS) {
+        emulator = types_1.Emulators.FUNCTIONS;
+    }
     let host = ((_b = (_a = options.config.src.emulators) === null || _a === void 0 ? void 0 : _a[emulator]) === null || _b === void 0 ? void 0 : _b.host) || constants_1.Constants.getDefaultHost(emulator);
     if (host === "localhost" && utils.isRunningInWSL()) {
         host = "127.0.0.1";
@@ -56,7 +63,7 @@ async function getAndCheckAddress(emulator, options) {
     if (!portOpen) {
         if (findAvailablePort) {
             const newPort = await portUtils.findAvailablePort(host, port);
-            if (newPort != port) {
+            if (newPort !== port) {
                 loggerForEmulator.logLabeled("WARN", emulator, `${constants_1.Constants.description(emulator)} unable to start on port ${port}, starting on ${newPort} instead.`);
                 port = newPort;
             }
@@ -86,7 +93,7 @@ async function getAndCheckAddress(emulator, options) {
 }
 async function startEmulator(instance) {
     const name = instance.getName();
-    track("Emulator Run", name);
+    void track("Emulator Run", name);
     await registry_1.EmulatorRegistry.start(instance);
 }
 exports.startEmulator = startEmulator;
@@ -115,7 +122,11 @@ async function cleanShutdown() {
 }
 exports.cleanShutdown = cleanShutdown;
 function filterEmulatorTargets(options) {
-    let targets = types_1.ALL_SERVICE_EMULATORS.filter((e) => {
+    let targets = [...types_1.ALL_SERVICE_EMULATORS];
+    if (previews_1.previews.extensionsemulator) {
+        targets.push(types_1.Emulators.EXTENSIONS);
+    }
+    targets = targets.filter((e) => {
         return options.config.has(e) || options.config.has(`emulators.${e}`);
     });
     const onlyOptions = options.only;
@@ -222,7 +233,7 @@ async function startAll(options, showUI = true) {
     if (shouldStart(options, types_1.Emulators.HUB)) {
         const hubAddr = await getAndCheckAddress(types_1.Emulators.HUB, options);
         const hub = new hub_1.EmulatorHub(Object.assign({ projectId }, hubAddr));
-        track("emulators:start", "hub");
+        void track("emulators:start", "hub");
         await startEmulator(hub);
     }
     let exportMetadata = {
@@ -239,19 +250,47 @@ async function startAll(options, showUI = true) {
             hubLogger.logLabeled("WARN", "emulators", `Could not find import/export metadata file, ${clc.bold("skipping data import!")}`);
         }
     }
+    const emulatableBackends = [];
+    const projectDir = (options.extDevDir || options.config.projectDir);
     if (shouldStart(options, types_1.Emulators.FUNCTIONS)) {
-        const functionsLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
-        const functionsAddr = await getAndCheckAddress(types_1.Emulators.FUNCTIONS, options);
-        const projectId = (0, projectUtils_1.needProjectId)(options);
         utils.assertDefined(options.config.src.functions);
         utils.assertDefined(options.config.src.functions.source, "Error: 'functions.source' is not defined");
-        utils.assertIsStringOrUndefined(options.extensionDir);
-        const projectDir = options.extensionDir || options.config.projectDir;
+        utils.assertIsStringOrUndefined(options.extDevDir);
         const functionsDir = path.join(projectDir, options.config.src.functions.source);
+        emulatableBackends.push({
+            functionsDir,
+            env: Object.assign({}, options.extDevEnv),
+            secretEnv: [],
+            predefinedTriggers: options.extDevTriggers,
+            nodeMajorVersion: (0, functionsEmulatorUtils_1.parseRuntimeVersion)(options.extDevNodeVersion || options.config.get("functions.runtime")),
+        });
+    }
+    if (shouldStart(options, types_1.Emulators.EXTENSIONS) && previews_1.previews.extensionsemulator) {
+        const projectNumber = constants_1.Constants.isDemoProject(projectId)
+            ? constants_1.Constants.FAKE_PROJECT_NUMBER
+            : await (0, projectUtils_1.needProjectNumber)(options);
+        const aliases = (0, projectUtils_1.getAliases)(options, projectId);
+        const extensionEmulator = new extensionsEmulator_1.ExtensionsEmulator({
+            projectId,
+            projectDir: options.config.projectDir,
+            projectNumber,
+            aliases,
+            extensions: options.config.get("extensions"),
+        });
+        const extensionsBackends = await extensionEmulator.getExtensionBackends();
+        const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
+        emulatableBackends.push(...filteredExtensionsBackends);
+        void track("Emulator Run", types_1.Emulators.EXTENSIONS);
+        registry_1.EmulatorRegistry.registerExtensionsEmulator();
+    }
+    if (emulatableBackends.length) {
+        const functionsLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
+        const functionsAddr = await getAndCheckAddress(types_1.Emulators.FUNCTIONS, options);
+        const projectId = (0, projectUtils_1.needProjectId)(options);
         let inspectFunctions;
         if (options.inspectFunctions) {
             inspectFunctions = commandUtils.parseInspectionPort(options);
-            functionsLogger.logLabeled("WARN", "functions", `You are running the functions emulator in debug mode (port=${inspectFunctions}). This means that functions will execute in sequence rather than in parallel.`);
+            functionsLogger.logLabeled("WARN", "functions", `You are running the Functions emulator in debug mode (port=${inspectFunctions}). This means that functions will execute in sequence rather than in parallel.`);
         }
         const emulatorsNotRunning = types_1.ALL_SERVICE_EMULATORS.filter((e) => {
             return e !== types_1.Emulators.FUNCTIONS && !shouldStart(options, e);
@@ -260,14 +299,6 @@ async function startAll(options, showUI = true) {
             functionsLogger.logLabeled("WARN", "functions", `The following emulators are not running, calls to these services from the Functions emulator will affect production: ${clc.bold(emulatorsNotRunning.join(", "))}`);
         }
         const account = (0, auth_2.getProjectDefaultAccount)(options.projectRoot);
-        const emulatableBackends = [
-            {
-                functionsDir,
-                env: Object.assign({}, options.extensionEnv),
-                predefinedTriggers: options.extensionTriggers,
-                nodeMajorVersion: (0, functionsEmulatorUtils_1.parseRuntimeVersion)(options.extensionNodeVersion || options.config.get("functions.runtime")),
-            },
-        ];
         const functionsEmulator = new functionsEmulator_1.FunctionsEmulator({
             projectId,
             projectDir,
@@ -276,6 +307,7 @@ async function startAll(options, showUI = true) {
             host: functionsAddr.host,
             port: functionsAddr.port,
             debugPort: inspectFunctions,
+            projectAlias: options.projectAlias,
         });
         await startEmulator(functionsEmulator);
     }
@@ -395,15 +427,11 @@ async function startAll(options, showUI = true) {
     }
     if (shouldStart(options, types_1.Emulators.STORAGE)) {
         const storageAddr = await getAndCheckAddress(types_1.Emulators.STORAGE, options);
-        const storageConfig = options.config.data.storage;
-        if (!(storageConfig === null || storageConfig === void 0 ? void 0 : storageConfig.rules)) {
-            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");
-        }
         const storageEmulator = new storage_1.StorageEmulator({
             host: storageAddr.host,
             port: storageAddr.port,
             projectId: projectId,
-            rules: options.config.path(storageConfig.rules),
+            rules: (0, config_1.getStorageRulesConfig)(projectId, options),
         });
         await startEmulator(storageEmulator);
         if (exportMetadata.storage) {
@@ -425,13 +453,15 @@ async function startAll(options, showUI = true) {
     if (showUI && !shouldStart(options, types_1.Emulators.UI)) {
         hubLogger.logLabeled("WARN", "emulators", "The Emulator UI requires a project ID to start. Configure your default project with 'firebase use' or pass the --project flag.");
     }
-    if (showUI && shouldStart(options, types_1.Emulators.UI)) {
+    if (showUI && (shouldStart(options, types_1.Emulators.UI) || START_LOGGING_EMULATOR)) {
         const loggingAddr = await getAndCheckAddress(types_1.Emulators.LOGGING, options);
         const loggingEmulator = new loggingEmulator_1.LoggingEmulator({
             host: loggingAddr.host,
             port: loggingAddr.port,
         });
         await startEmulator(loggingEmulator);
+    }
+    if (showUI && shouldStart(options, types_1.Emulators.UI)) {
         const uiAddr = await getAndCheckAddress(types_1.Emulators.UI, options);
         const ui = new ui_1.EmulatorUI(Object.assign({ projectId: projectId, auto_download: true }, uiAddr));
         await startEmulator(ui);

package/lib/emulator/download.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadEmulator = void 0;
+exports.downloadExtensionVersion = exports.downloadEmulator = void 0;
 const crypto = require("crypto");
 const fs = require("fs-extra");
 const path = require("path");
@@ -32,6 +32,23 @@ async function downloadEmulator(name) {
     removeOldFiles(name, emulator);
 }
 exports.downloadEmulator = downloadEmulator;
+async function downloadExtensionVersion(extensionVersionRef, sourceDownloadUri, targetDir) {
+    const emulatorLogger = emulatorLogger_1.EmulatorLogger.forExtension({ ref: extensionVersionRef });
+    emulatorLogger.logLabeled("BULLET", "extensions", `Starting download for ${extensionVersionRef} source code...`);
+    try {
+        fs.mkdirSync(targetDir);
+    }
+    catch (err) {
+        emulatorLogger.logLabeled("BULLET", "extensions", `cache directory for ${extensionVersionRef} already exists...`);
+    }
+    emulatorLogger.logLabeled("BULLET", "extensions", `downloading ${sourceDownloadUri}...`);
+    const sourceCodeZip = await downloadUtils.downloadToTmp(sourceDownloadUri);
+    await 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)

package/lib/emulator/downloadableEmulators.js

@@ -148,8 +148,8 @@ const Commands = {
     storage: {
         binary: "java",
         args: [
-            "-jar",
             "-Duser.language=en",
+            "-jar",
             getExecPath(types_1.Emulators.STORAGE),
             "serve",
         ],

package/lib/emulator/emulatorLogger.js

@@ -34,7 +34,7 @@ class EmulatorLogger {
             },
         });
     }
-    static forFunction(functionName) {
+    static forFunction(functionName, extensionLogInfo) {
         return new EmulatorLogger({
             metadata: {
                 emulator: {
@@ -43,6 +43,17 @@ class EmulatorLogger {
                 function: {
                     name: functionName,
                 },
+                extension: extensionLogInfo,
+            },
+        });
+    }
+    static forExtension(extensionLogInfo) {
+        return new EmulatorLogger({
+            metadata: {
+                emulator: {
+                    name: "extensions",
+                },
+                extension: extensionLogInfo,
             },
         });
     }

package/lib/emulator/extensions/validation.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUnemulatedTriggerTypes = exports.getUnemulatedAPIs = void 0;
+const planner = require("../../deploy/extensions/planner");
+const controller_1 = require("../controller");
+const constants_1 = require("../constants");
+const ensureApiEnabled_1 = require("../../ensureApiEnabled");
+const functionsEmulatorShared_1 = require("../functionsEmulatorShared");
+const types_1 = require("../types");
+const EMULATED_APIS = [
+    "storage-component.googleapis.com",
+    "firestore.googleapis.com",
+    "pubsub.googleapis.com",
+    "identitytoolkit.googleapis.com",
+];
+async function getUnemulatedAPIs(projectId, instances) {
+    var _a;
+    const unemulatedAPIs = {};
+    for (const i of instances) {
+        const extensionVersion = await planner.getExtensionVersion(i);
+        for (const api of (_a = extensionVersion.spec.apis) !== null && _a !== void 0 ? _a : []) {
+            if (!EMULATED_APIS.includes(api.apiName)) {
+                if (unemulatedAPIs[api.apiName]) {
+                    unemulatedAPIs[api.apiName].instanceIds.push(i.instanceId);
+                }
+                else {
+                    const enabled = !constants_1.Constants.isDemoProject(projectId) &&
+                        (await (0, ensureApiEnabled_1.check)(projectId, api.apiName, "extensions", true));
+                    unemulatedAPIs[api.apiName] = {
+                        apiName: api.apiName,
+                        instanceIds: [i.instanceId],
+                        enabled,
+                    };
+                }
+            }
+        }
+    }
+    return Object.values(unemulatedAPIs);
+}
+exports.getUnemulatedAPIs = getUnemulatedAPIs;
+function checkForUnemulatedTriggerTypes(backend, options) {
+    var _a;
+    const triggers = (_a = backend.predefinedTriggers) !== null && _a !== void 0 ? _a : [];
+    const unemulatedTriggers = triggers
+        .filter((definition) => {
+        if (definition.httpsTrigger) {
+            return false;
+        }
+        if (definition.eventTrigger) {
+            const service = (0, functionsEmulatorShared_1.getFunctionService)(definition);
+            switch (service) {
+                case constants_1.Constants.SERVICE_FIRESTORE:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.FIRESTORE);
+                case constants_1.Constants.SERVICE_REALTIME_DATABASE:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.DATABASE);
+                case constants_1.Constants.SERVICE_PUBSUB:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.PUBSUB);
+                case constants_1.Constants.SERVICE_AUTH:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.AUTH);
+                case constants_1.Constants.SERVICE_STORAGE:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.STORAGE);
+                default:
+                    return true;
+            }
+        }
+    })
+        .map((definition) => constants_1.Constants.getServiceName((0, functionsEmulatorShared_1.getFunctionService)(definition)));
+    return [...new Set(unemulatedTriggers)];
+}
+exports.checkForUnemulatedTriggerTypes = checkForUnemulatedTriggerTypes;

package/lib/emulator/extensionsEmulator.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsEmulator = void 0;
+const fs = require("fs-extra");
+const os = require("os");
+const path = require("path");
+const clc = require("cli-color");
+const Table = require("cli-table");
+const child_process_1 = require("child_process");
+const planner = require("../deploy/extensions/planner");
+const error_1 = require("../error");
+const refs_1 = require("../extensions/refs");
+const download_1 = require("./download");
+const optionsHelper_1 = require("../extensions/emulator/optionsHelper");
+const emulatorLogger_1 = require("./emulatorLogger");
+const types_1 = require("./types");
+const validation_1 = require("./extensions/validation");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
+const shortenUrl_1 = require("../shortenUrl");
+const constants_1 = require("./constants");
+class ExtensionsEmulator {
+    constructor(args) {
+        this.want = [];
+        this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.EXTENSIONS);
+        this.pendingDownloads = new Map();
+        this.args = args;
+    }
+    async readManifest() {
+        var _a;
+        this.want = await planner.want({
+            projectId: this.args.projectId,
+            projectNumber: this.args.projectNumber,
+            aliases: (_a = this.args.aliases) !== null && _a !== void 0 ? _a : [],
+            projectDir: this.args.projectDir,
+            extensions: this.args.extensions,
+            emulatorMode: true,
+        });
+    }
+    async ensureSourceCode(instance) {
+        if (!instance.ref) {
+            throw new error_1.FirebaseError(`No ref found for ${instance.instanceId}. Emulating local extensions is not yet supported.`);
+        }
+        const ref = (0, refs_1.toExtensionVersionRef)(instance.ref);
+        const cacheDir = process.env.FIREBASE_EXTENSIONS_CACHE_PATH ||
+            path.join(os.homedir(), ".cache", "firebase", "extensions");
+        const sourceCodePath = path.join(cacheDir, ref);
+        if (this.pendingDownloads.get(ref)) {
+            await this.pendingDownloads.get(ref);
+        }
+        if (!this.hasValidSource({ path: sourceCodePath, extRef: ref })) {
+            const promise = this.downloadSource(instance, ref, sourceCodePath);
+            this.pendingDownloads.set(ref, promise);
+            await promise;
+        }
+        return sourceCodePath;
+    }
+    async downloadSource(instance, ref, sourceCodePath) {
+        const extensionVersion = await planner.getExtensionVersion(instance);
+        await (0, download_1.downloadExtensionVersion)(ref, extensionVersion.sourceDownloadUri, sourceCodePath);
+        this.installAndBuildSourceCode(sourceCodePath);
+    }
+    hasValidSource(args) {
+        const requiredFiles = [
+            "./extension.yaml",
+            "./functions/package.json",
+            "./functions/node_modules",
+        ];
+        for (const requiredFile of requiredFiles) {
+            const f = path.join(args.path, requiredFile);
+            if (!fs.existsSync(f)) {
+                emulatorLogger_1.EmulatorLogger.forExtension({ ref: args.extRef }).logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extRef}, expected to find ${f}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    installAndBuildSourceCode(sourceCodePath) {
+        const npmInstall = (0, child_process_1.spawnSync)("npm", ["--prefix", `/${sourceCodePath}/functions/`, "install"], {
+            encoding: "utf8",
+        });
+        if (npmInstall.error) {
+            throw npmInstall.error;
+        }
+        const npmRunGCPBuild = (0, child_process_1.spawnSync)("npm", ["--prefix", `/${sourceCodePath}/functions/`, "run", "gcp-build"], { encoding: "utf8" });
+        if (npmRunGCPBuild.error) {
+            throw npmRunGCPBuild.error;
+        }
+    }
+    async getExtensionBackends() {
+        await this.readManifest();
+        await this.checkAndWarnAPIs(this.want);
+        return Promise.all(this.want.map((i) => {
+            return this.toEmulatableBackend(i);
+        }));
+    }
+    async toEmulatableBackend(instance) {
+        const extensionDir = await this.ensureSourceCode(instance);
+        const functionsDir = path.join(extensionDir, "functions");
+        const env = Object.assign(this.autoPopulatedParams(instance), instance.params);
+        const { extensionTriggers, nodeMajorVersion, nonSecretEnv, secretEnvVariables } = await (0, optionsHelper_1.getExtensionFunctionInfo)(extensionDir, instance.instanceId, env);
+        const extension = await planner.getExtension(instance);
+        const extensionVersion = await planner.getExtensionVersion(instance);
+        return {
+            functionsDir,
+            env: nonSecretEnv,
+            secretEnv: secretEnvVariables,
+            predefinedTriggers: extensionTriggers,
+            nodeMajorVersion: nodeMajorVersion,
+            extensionInstanceId: instance.instanceId,
+            extension,
+            extensionVersion,
+        };
+    }
+    autoPopulatedParams(instance) {
+        const projectId = this.args.projectId;
+        return {
+            PROJECT_ID: projectId !== null && projectId !== void 0 ? projectId : "",
+            EXT_INSTANCE_ID: instance.instanceId,
+            DATABASE_INSTANCE: projectId !== null && projectId !== void 0 ? projectId : "",
+            DATABASE_URL: `https://${projectId}.firebaseio.com`,
+            STORAGE_BUCKET: `${projectId}.appspot.com`,
+        };
+    }
+    async checkAndWarnAPIs(instances) {
+        const apisToWarn = await (0, validation_1.getUnemulatedAPIs)(this.args.projectId, instances);
+        if (apisToWarn.length) {
+            const table = new Table({
+                head: [
+                    "API Name",
+                    "Instances using this API",
+                    `Enabled on ${this.args.projectId}`,
+                    `Enable this API`,
+                ],
+                style: { head: ["yellow"] },
+            });
+            for (const apiToWarn of apisToWarn) {
+                const enablementUri = await (0, shortenUrl_1.shortenUrl)((0, ensureApiEnabled_1.enableApiURI)(this.args.projectId, apiToWarn.apiName));
+                table.push([
+                    apiToWarn.apiName,
+                    apiToWarn.instanceIds,
+                    apiToWarn.enabled ? "Yes" : "No",
+                    apiToWarn.enabled ? "" : clc.bold.underline(enablementUri),
+                ]);
+            }
+            if (constants_1.Constants.isDemoProject(this.args.projectId)) {
+                this.logger.logLabeled("WARN", "Extensions", "The following Extensions make calls to Google Cloud APIs that do not have Emulators. " +
+                    `${clc.bold(this.args.projectId)} is a demo project, so these Extensions may not work as expected.\n` +
+                    table.toString());
+            }
+            else {
+                this.logger.logLabeled("WARN", "Extensions", "The following Extensions make calls to Google Cloud APIs that do not have Emulators. " +
+                    `These calls will go to production Google Cloud APIs which may have real effects on ${clc.bold(this.args.projectId)}.\n` +
+                    table.toString());
+            }
+        }
+    }
+    filterUnemulatedTriggers(options, backends) {
+        let foundUnemulatedTrigger = false;
+        const filteredBackends = backends.filter((backend) => {
+            const unemulatedServices = (0, validation_1.checkForUnemulatedTriggerTypes)(backend, options);
+            if (unemulatedServices.length) {
+                foundUnemulatedTrigger = true;
+                const msg = ` ignored becuase it includes ${unemulatedServices.join(", ")} triggered functions, and the ${unemulatedServices.join(", ")} emulator does not exist or is not running.`;
+                this.logger.logLabeled("WARN", `extensions[${backend.extensionInstanceId}]`, msg);
+            }
+            return unemulatedServices.length === 0;
+        });
+        if (foundUnemulatedTrigger) {
+            const msg = "No Cloud Functions for these instances will be emulated, because partially emulating an Extension can lead to unexpected behavior. ";
+            this.logger.log("WARN", msg);
+        }
+        return filteredBackends;
+    }
+}
+exports.ExtensionsEmulator = ExtensionsEmulator;